| /************************************************************************ |
| * |
| * 23.list.h - definitions of helpers used in clause 23.list tests |
| * |
| * $Id$ |
| * |
| *************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| **************************************************************************/ |
| |
| #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 |
