KeyedVector.h

Go to the documentation of this file.

/*
 * Copyright (c) 2005 Palmsource, Inc.
 * 
 * This software is licensed as described in the file LICENSE, which
 * you should have received as part of this distribution. The terms
 * are also available at http://www.openbinder.org/license.html.
 * 
 * This software consists of voluntary contributions made by many
 * individuals. For the exact contribution history, see the revision
 * history and logs, available at http://www.openbinder.org
 */

#ifndef _SUPPORT_ASSOCIATIVEVECTOR_H
#define _SUPPORT_ASSOCIATIVEVECTOR_H

#include <support/Vector.h>
#include <support/SortedVector.h>

#if _SUPPORTS_NAMESPACE
namespace palmos {
namespace support {
#endif

/*--------------------------------------------------------*/
/*----- SAbstractKeyedVector class -----------------------*/

class SAbstractKeyedVector
{
public:
    inline                  SAbstractKeyedVector();
    inline virtual          ~SAbstractKeyedVector();

            const void*     AbstractValueAt(size_t index) const;
            const void*     AbstractKeyAt(size_t index) const;
            const void*     KeyedFor(const void* key, bool* found) const;
            const void*     FloorKeyedFor(const void* key, bool* found) const;
            const void*     CeilKeyedFor(const void* key, bool* found) const;
            void*           EditKeyedFor(const void* key, bool* found);
            ssize_t         AddKeyed(const void* key, const void* value);
            void            RemoveItemsAt(size_t index, size_t count);
            ssize_t         RemoveKeyed(const void* key);
            size_t          CountItems() const;

private:
            int32_t         _reserved_data;     // align to 8 bytes
};

/*--------------------------------------------------------*/
/*----- SKeyedVector class -------------------------------*/


template<class KEY, class VALUE>
class SKeyedVector : private SAbstractKeyedVector
{
public:
            typedef KEY key_type;
            typedef VALUE   value_type;

public:
                            SKeyedVector();
                            SKeyedVector(const VALUE& undef);
                            SKeyedVector(   const SSortedVector<KEY>& keys,
                                            const SVector<VALUE>& values,
                                            const VALUE& undef = VALUE());
    virtual                 ~SKeyedVector();
    
            void            SetTo(const SKeyedVector<KEY,VALUE>& o);
    
    /* Size stats */
    
            void            SetCapacity(size_t total_space);
            void            SetExtraCapacity(size_t extra_space);
            size_t          Capacity() const;
            
            size_t          CountItems() const;
        
    /* Value by Key */

            const VALUE&    ValueFor(const KEY& key, bool* found = NULL) const;
    inline  const VALUE&    operator[](const KEY& key) const { return ValueFor(key); }

            const VALUE&    FloorValueFor(const KEY& key, bool* found = NULL) const;
            const VALUE&    CeilValueFor(const KEY& key, bool* found = NULL) const;

            VALUE&          EditValueFor(const KEY& key, bool* found = NULL);
            
    /* Value/Key by index */

            const KEY&      KeyAt(size_t i) const;
            const VALUE&    ValueAt(size_t i) const;
            VALUE&          EditValueAt(size_t i);
            
            const SSortedVector<KEY>&   KeyVector() const;
            const SVector<VALUE>&       ValueVector() const;
            SVector<VALUE>&             ValueVector();
            
    /* List manipulation */

            ssize_t         IndexOf(const KEY& key) const;
            ssize_t         FloorIndexOf(const KEY& key) const;
            ssize_t         CeilIndexOf(const KEY& key) const;
            bool            GetIndexOf(const KEY& key, size_t* index) const;
            
            ssize_t         AddItem(const KEY& key, const VALUE& value);
            
            void            RemoveItemsAt(size_t index, size_t count = 1);
            ssize_t         RemoveItemFor(const KEY& key);
            
            void            MakeEmpty();
            
            void            Swap(SKeyedVector<KEY,VALUE>& o);
            
private:
                            SKeyedVector(const SKeyedVector<KEY,VALUE>& o);
            SKeyedVector<KEY,VALUE>&    operator=(const SKeyedVector<KEY,VALUE>& o);

            SSortedVector<KEY>  m_keys;
            SVector<VALUE>      m_values;
            VALUE               m_undefined;
};

// Type optimizations.
template<class KEY, class VALUE>
void BSwap(SKeyedVector<KEY, VALUE>& v1, SKeyedVector<KEY, VALUE>& v2);

/*-------------------------------------------------------------*/
/*---- No user serviceable parts after this -------------------*/

SAbstractKeyedVector::SAbstractKeyedVector()
    : _reserved_data(0)
{
}

SAbstractKeyedVector::~SAbstractKeyedVector()
{
}

/*-------------------------------------------------------------*/

template<class KEY, class VALUE> inline
SKeyedVector<KEY,VALUE>::SKeyedVector()
    :   m_undefined(VALUE())
{
}

template<class KEY, class VALUE> inline
SKeyedVector<KEY,VALUE>::SKeyedVector(const VALUE& undef)
    :   m_undefined(undef)
{
}

template<class KEY, class VALUE> inline
SKeyedVector<KEY,VALUE>::SKeyedVector(const SSortedVector<KEY>& keys,
            const SVector<VALUE>& values, const VALUE& undef)
    :   m_keys(keys), m_values(values), m_undefined(undef)
{
}

template<class KEY, class VALUE> inline
SKeyedVector<KEY,VALUE>::~SKeyedVector()
{
}

template<class KEY, class VALUE> inline
void SKeyedVector<KEY,VALUE>::SetTo(const SKeyedVector<KEY,VALUE>& o)
{
    m_keys = o.m_keys; m_values = o.m_values; m_undefined = o.m_undefined;
}

template<class KEY, class VALUE> inline
void SKeyedVector<KEY,VALUE>::SetCapacity(size_t total_space)
{
    m_keys.SetCapacity(total_space); m_values.SetCapacity(total_space);
}

template<class KEY, class VALUE> inline
void SKeyedVector<KEY,VALUE>::SetExtraCapacity(size_t extra_space)
{
    m_keys.SetExtraCapacity(extra_space); m_values.SetExtraCapacity(extra_space);
}

template<class KEY, class VALUE> inline
size_t SKeyedVector<KEY,VALUE>::Capacity() const
{
    return m_keys.Capacity();
}

template<class KEY, class VALUE> inline
size_t SKeyedVector<KEY,VALUE>::CountItems() const
{
    return m_keys.CountItems();
}

template<class KEY, class VALUE> inline
const VALUE& SKeyedVector<KEY,VALUE>::ValueFor(const KEY& key, bool* found) const
{
    return *(const VALUE*)KeyedFor(&key, found);
}

template<class KEY, class VALUE> inline
const VALUE& SKeyedVector<KEY,VALUE>::FloorValueFor(const KEY& key, bool* found) const
{
    return *(const VALUE*)FloorKeyedFor(&key, found);
}

template<class KEY, class VALUE> inline
const VALUE& SKeyedVector<KEY,VALUE>::CeilValueFor(const KEY& key, bool* found) const
{
    return *(const VALUE*)CeilKeyedFor(&key, found);
}

template<class KEY, class VALUE> inline
VALUE& SKeyedVector<KEY,VALUE>::EditValueFor(const KEY& key, bool* found)
{
    return *(VALUE*)EditKeyedFor(&key, found);
}

template<class KEY, class VALUE> inline
const KEY& SKeyedVector<KEY,VALUE>::KeyAt(size_t i) const
{
    return m_keys.ItemAt(i);
}

template<class KEY, class VALUE> inline
const VALUE& SKeyedVector<KEY,VALUE>::ValueAt(size_t i) const
{
    return m_values.ItemAt(i);
}

template<class KEY, class VALUE> inline
VALUE& SKeyedVector<KEY,VALUE>::EditValueAt(size_t i)
{
    return m_values.EditItemAt(i);
}

template<class KEY, class VALUE> inline
const SSortedVector<KEY>& SKeyedVector<KEY,VALUE>::KeyVector() const
{
    return m_keys;
}

template<class KEY, class VALUE> inline
const SVector<VALUE>& SKeyedVector<KEY,VALUE>::ValueVector() const
{
    return m_values;
}

template<class KEY, class VALUE> inline
SVector<VALUE>& SKeyedVector<KEY,VALUE>::ValueVector()
{
    return m_values;
}

template<class KEY, class VALUE> inline
ssize_t SKeyedVector<KEY,VALUE>::IndexOf(const KEY& key) const
{
    return m_keys.IndexOf(key);
}

template<class KEY, class VALUE> inline
ssize_t SKeyedVector<KEY,VALUE>::FloorIndexOf(const KEY& key) const
{
    return m_keys.FloorIndexOf(key);
}

template<class KEY, class VALUE> inline
ssize_t SKeyedVector<KEY,VALUE>::CeilIndexOf(const KEY& key) const
{
    return m_keys.CeilIndexOf(key);
}

template<class KEY, class VALUE> inline
bool SKeyedVector<KEY,VALUE>::GetIndexOf(const KEY& key, size_t* index) const
{
    return m_keys.GetIndexOf(key, index);
}

template<class KEY, class VALUE> inline
ssize_t SKeyedVector<KEY,VALUE>::AddItem(const KEY& key, const VALUE& value)
{
    return AddKeyed(&key, &value);
}

template<class KEY, class VALUE> inline
void SKeyedVector<KEY,VALUE>::RemoveItemsAt(size_t index, size_t count)
{
    SAbstractKeyedVector::RemoveItemsAt(index, count);
}

template<class KEY, class VALUE> inline
ssize_t SKeyedVector<KEY,VALUE>::RemoveItemFor(const KEY& key)
{
    return RemoveKeyed(&key);
}

template<class KEY, class VALUE> inline
void SKeyedVector<KEY,VALUE>::MakeEmpty()
{
    m_keys.MakeEmpty(); m_values.MakeEmpty();
}

template<class KEY, class VALUE> inline
void SKeyedVector<KEY, VALUE>::Swap(SKeyedVector<KEY, VALUE>& o)
{
    BSwap(m_keys, o.m_keys);
    BSwap(m_values, o.m_values);
    BSwap(m_undefined, o.m_undefined);
}

template<class KEY, class VALUE> inline
void BSwap(SKeyedVector<KEY, VALUE>& v1, SKeyedVector<KEY, VALUE>& v2)
{
    v1.Swap(v2);
}

#if _SUPPORTS_NAMESPACE
} } // namespace palmos::support
#endif

#endif

---

Generated on Wed Dec 28 22:33:28 2005 by Doxygen 1.4.4 for OpenBinder Documentation Version 1.0

PalmSource, Inc. © 2005