rw_lists.h

Go to the documentation of this file.

 
#ifndef RW_23_LIST_H_INCLUDED
#define RW_23_LIST_H_INCLUDED
 
#include <rw_containers.h>
#include <rw_driver.h>      // for rw_assert()
#include <rw_sigdefs.h>     // for helper macros
 
 
// defines enumerations identifying list template arguments,
// sets of overloaded functions, member types used in the declarations
// of their signatures, and specific overloads of such member functions
struct ListIds : ContainerIds
{
    // unique identifiers for all overloads of each member function
    //     6 bits for FuncId
    // 6 * 4 bits for ArgId (at most 6 arguments including this)
    //     1 bit for membership
    enum OverloadId {
        // list ()
        MEMBER_0 (ctor, cont),
        // list (const allocator_type&)
        MEMBER_1 (ctor, cont, alloc),
        // list (const list&)
        MEMBER_1 (ctor, cont, ccont),
        // list (size_type)
        MEMBER_1 (ctor, cont, size),
        // list (size_type, const value_type&)
        MEMBER_2 (ctor, cont, size, cref),
        // list (size_type, const value_type&, const allocator_type&)
        MEMBER_3 (ctor, cont, size, cref, alloc),
        // list (InputIterator, InputIterator)
        MEMBER_1 (ctor, cont, range),
        // list (InputIterator, InputIterator, const allocator&)
        MEMBER_2 (ctor, cont, range, alloc),
 
        // operator= (const list&)
        MEMBER_1 (op_set, cont, ccont),
 
        // assign (size_type, const value_type&)
        MEMBER_2 (assign, cont, size, cref),
        // assign (InputIterator, InputIterator)
        MEMBER_1 (assign, cont, range),
 
        // get_allocator () const
        MEMBER_0 (get_allocator, ccont),
 
        // begin ()
        MEMBER_0 (begin, cont),
        // begin () const
        MEMBER_0 (begin_const, ccont),
        // end ()
        MEMBER_0 (end, cont),
        // end () const
        MEMBER_0 (end_const, ccont),
 
        // rbegin ()
        MEMBER_0 (rbegin, cont),
        // rbegin () const
        MEMBER_0 (rbegin_const, ccont),
        // rend ()
        MEMBER_0 (rend, cont),
        // rend () const
        MEMBER_0 (rend_const, ccont),
 
        // empty ()
        MEMBER_0 (empty, ccont),
 
        // size ()
        MEMBER_0 (size, ccont),
 
        // max_size ()
        MEMBER_0 (max_size, ccont),
 
        // resize (size_type)
        MEMBER_1 (resize, cont, size),
        // resize (size_type, value_type)
        MEMBER_2 (resize, cont, size, val),
 
        // front ()
        MEMBER_0 (front, cont),
        // front () const
        MEMBER_0 (front_const, ccont),
        // back ()
        MEMBER_0 (back, cont),
        // back () const
        MEMBER_0 (back_const, ccont),
 
        // push_front (const value_type&)
        MEMBER_1 (push_front, cont, cref),
        // pop_front ()
        MEMBER_0 (pop_front, cont),
        // push_back (const value_type&)
        MEMBER_1 (push_back, cont, cref),
        // pop_back ()
        MEMBER_0 (pop_back, cont),
 
        // insert (iterator, const value_type&)
        MEMBER_2 (insert, cont, iter, cref),
        // insert (iterator, size_type, const value_type&)
        MEMBER_3 (insert, cont, iter, size, cref),
        // insert (iterator, InputIterator, InputIterator)
        MEMBER_2 (insert, cont, iter, range),
 
        // erase (iterator)
        MEMBER_1 (erase, cont, iter),
        // erase (iterator, iterator)
        MEMBER_2 (erase, cont, iter, iter),
 
        // swap (list&)
        MEMBER_1 (swap, cont, cont),
        // swap (list&, list&)
        NON_MEMBER_2 (swap, cont, cont),
 
        // clear ()
        MEMBER_0 (clear, cont),
 
        // splice (iterator, list&)
        MEMBER_2 (splice, cont, iter, cont),
        // splice (iterator, list&, iterator)
        MEMBER_3 (splice, cont, iter, cont, iter),
        // splice (iterator, list&, iterator, iterator)
        MEMBER_4 (splice, cont, iter, cont, iter, iter),
 
        // remove (const value_type&)
        MEMBER_1 (remove, cont, cref),
        // remove_if (Predicate)
        MEMBER_1 (remove_if, cont, pred),
 
        // unique (BinaryPredicate)
        MEMBER_1 (unique, cont, bpred),
 
        // merge (list&)
        MEMBER_1 (merge, cont, cont),
        // merge (list&, Compare)
        MEMBER_2 (merge, cont, cont, comp),
 
        // sort ()
        MEMBER_0 (sort, cont),
        // sort (Compare)
        MEMBER_1 (sort, cont, comp),
 
        // reverse ()
        MEMBER_0 (reverse, cont),
 
        // operator== (const list&, const list&)
        NON_MEMBER_2 (op_equal, ccont, ccont),
 
        // operator< (const list&, const list&)
        NON_MEMBER_2 (op_less, ccont, ccont),
 
        // operator!= (const list&, const list&)
        NON_MEMBER_2 (op_not_equal, ccont, ccont),
 
        // operator> (const list&, const list&)
        NON_MEMBER_2 (op_greater, ccont, ccont),
 
        // operator>= (const list&, const list&)
        NON_MEMBER_2 (op_greater_equal, ccont, ccont),
 
        // operator<= (const list&, const list&)
        NON_MEMBER_2 (op_less_equal, ccont, ccont)
    };
 
// clean up helper macros used above
#include <rw_sigdefs.h>
 
};
 
 
template <class InputIter1, class InputIter2>
inline bool
_rw_equal (InputIter1 first1, InputIter1 last1, InputIter2 first2)
{
    for (; first1 != last1 && *first1 == *first2; ++first1, ++first2) ;
 
    return first1 == last1;
}
 
// encapsulates the state of a list object
// used in exception safety tests to determine changes to the state
// after a modifying operation throws an exception
template <class List>
struct ListState
{
    typedef typename List::const_iterator  ListCIter;
    typedef typename List::const_pointer   ListCPtr;
 
    _RWSTD_SIZE_T size_;
    ListCIter*    iters_;
    ListCPtr*     ptrs_;
 
    ListState (List const & lst) : size_ (lst.size ()), iters_ (0), ptrs_ (0) {
        iters_ = new ListCIter [size_];
        ptrs_  = new ListCPtr  [size_];
 
        _RWSTD_SIZE_T index = 0;
        for (ListCIter it = lst.begin (), end = lst.end ();
            it != end; ++it, ++index) {
 
            iters_ [index] = it;
            ptrs_  [index] = &*it;
        }
    }
 
    ~ListState () {
        delete [] iters_;
        delete [] ptrs_;
    }
 
    // invokes rw_assert() to verify that two states are the same
    void assert_equal (const ListState& state, int line,
                       int case_line, const char* when) const {
 
        const bool equal =    size_ == state.size_
                           && _rw_equal (iters_, iters_ + size_, state.iters_)
                           && _rw_equal (ptrs_,  ptrs_ + size_,  state.ptrs_);
 
        rw_assert (equal, 0, case_line,
                   "line %d: %{$FUNCALL}: object state unexpectedly changed "
                   "after %s", line, when);
    }
};
 
 
#endif   // RW_23_LIST_H_INCLUDED