ListMutableSet< T, _Compare > Class Template Reference

#include <key_mutable_set.h>

Inheritance diagram for ListMutableSet< T, _Compare >:

Public Member Functions
void	flatten ()
void	checkSet ()
	This just checks the order of the set for testing purposes.. More...
void	changeKey (typename SUPER::iterator &iter, const T &newKey, typename SUPER::iterator &templess, typename SUPER::iterator &rettempmore)
	Given an iterator you can alter that iterator's key to be the one passed in. More...
SUPER::iterator	changeKey (typename SUPER::iterator iter, const T &newKey)
SUPER::iterator	insert (const T &newKey, typename SUPER::iterator hint)
SUPER::iterator	insert (const T &newKey)

Detailed Description

template<class T, class _Compare = std::less< T >>
class ListMutableSet< T, _Compare >

Definition at line 104 of file key_mutable_set.h.

Member Function Documentation

template<class T , class _Compare = std::less< T >>

void ListMutableSet< T, _Compare >::changeKey ( typename SUPER::iterator &  iter, const T &  newKey, typename SUPER::iterator &  templess, typename SUPER::iterator &  rettempmore  )

inline

Given an iterator you can alter that iterator's key to be the one passed in.

The type must have a function called changeKey(const Key &newKey) that changes its key to the specified new key.

Definition at line 122 of file key_mutable_set.h.

References ListMutableSet< T, _Compare >::insert().

Referenced by ListMutableSet< T, _Compare >::changeKey().

    {
        MutableShell< T >newKeyShell( newKey );
        templess = rettempmore = iter;
        ++rettempmore;
        typename SUPER::iterator tempmore = rettempmore;
        if ( tempmore == this->end() )
            --tempmore;
        if ( templess != this->begin() )
            --templess;
        _Compare comparator;
        if ( comparator( newKeyShell, *templess ) || comparator( *tempmore, newKeyShell ) ) {
            rettempmore = templess = iter = this->insert( newKeyShell, this->erase( iter ) );
            ++rettempmore;
            if ( templess != this->begin() )
                --templess;
        } else {
            **iter = newKey;
            //return iter;
        }
    }

template<class T , class _Compare = std::less< T >>

SUPER::iterator ListMutableSet< T, _Compare >::changeKey ( typename SUPER::iterator  iter, const T &  newKey  )

inline

Definition at line 147 of file key_mutable_set.h.

References ListMutableSet< T, _Compare >::changeKey().

    {
        typename SUPER::iterator templess = iter, tempmore = iter;
        changeKey( iter, newKey, templess, tempmore );
        return iter;
    }

template<class T , class _Compare = std::less< T >>

void ListMutableSet< T, _Compare >::checkSet ( )

inline

This just checks the order of the set for testing purposes..

Definition at line 111 of file key_mutable_set.h.

    {
        _Compare comparator;
        if ( this->begin() != this->end() )
            for (typename SUPER::iterator newiter = this->begin(), iter = newiter++; newiter != this->end(); iter = newiter++)
                assert( !comparator( *newiter, *iter ) );
    }

template<class T , class _Compare = std::less< T >>

void ListMutableSet< T, _Compare >::flatten ( )

inline

Definition at line 109 of file key_mutable_set.h.

{}

template<class T , class _Compare = std::less< T >>

SUPER::iterator ListMutableSet< T, _Compare >::insert ( const T &  newKey, typename SUPER::iterator  hint  )

inline

Definition at line 153 of file key_mutable_set.h.

Referenced by ListMutableSet< T, _Compare >::changeKey(), and ListMutableSet< T, _Compare >::insert().

    {
        bool     gequal = false, lequal = false;
        _Compare comparator;
        while (1) {
            if ( hint != this->end() ) {
                bool tlequal = !comparator( *hint, newKey );
                bool tgequal = !comparator( newKey, *hint );
                if (tlequal) {
                    if ( gequal || tgequal || hint == this->begin() ) {
                        return this->SUPER::insert( hint, newKey );
                    } else {
                        lequal = true;
                        --hint;
                    }
                }
                if (tgequal) {
                    gequal = true;
                    ++hint;
                    if (lequal || tlequal)
                        return this->SUPER::insert( hint, newKey );
                }
            } else if ( hint == this->begin() ) {
                this->SUPER::insert( hint, newKey );
            } else {
                if (gequal)
                    return this->SUPER::insert( hint, newKey );
                else
                    --hint;
            }
        }
    }

template<class T , class _Compare = std::less< T >>

SUPER::iterator ListMutableSet< T, _Compare >::insert ( const T &  newKey)

inline

Definition at line 185 of file key_mutable_set.h.

References ListMutableSet< T, _Compare >::insert().

    {
        return this->insert( newKey, this->begin() );
    }

---

The documentation for this class was generated from the following file:

• src/cmd/key_mutable_set.h