diff --git a/panda/src/putil/config_util.cxx b/panda/src/putil/config_util.cxx index 163e8b41b7..08f25ad1e8 100644 --- a/panda/src/putil/config_util.cxx +++ b/panda/src/putil/config_util.cxx @@ -73,8 +73,6 @@ ConfigureFn(config_util) { //const bool track_memory_usage = config_util.GetBool("track-memory-usage", false); -const bool paranoid_ordered_vector = config_util.GetBool("paranoid-ordered-vector", false); - DSearchPath & get_model_path() { static DSearchPath *model_path = NULL; diff --git a/panda/src/putil/config_util.h b/panda/src/putil/config_util.h index a70d8b7eca..9a76aeb499 100644 --- a/panda/src/putil/config_util.h +++ b/panda/src/putil/config_util.h @@ -36,8 +36,6 @@ NotifyCategoryDecl(bam, EXPCL_PANDA, EXPTP_PANDA); //extern EXPCL_PANDA const bool track_memory_usage; -extern EXPCL_PANDA const bool paranoid_ordered_vector; - // These are functions instead of constant variables because they are // computed based on the concatenation of all appearances of the // corresponding variable in the config files. diff --git a/panda/src/putil/ordered_vector.I b/panda/src/putil/ordered_vector.I index 05a9cdb1b3..e1e6d292ce 100644 --- a/panda/src/putil/ordered_vector.I +++ b/panda/src/putil/ordered_vector.I @@ -326,7 +326,6 @@ insert_unique(const ordered_vector::VALUE_TYPE &key) { } ITERATOR result = _vector.insert(position, key); - verify_list(); return pair(result, true); } @@ -348,7 +347,6 @@ insert_nonunique(const ordered_vector::VALUE_TYPE &key) { nassertr(position >= begin() && position <= end(), end()); ITERATOR result = _vector.insert(position, key); - verify_list(); return result; } @@ -662,45 +660,9 @@ find_insert_position(ordered_vector::ITERATOR first, ordered_vector::ITERATOR last, const ordered_vector::KEY_TYPE &key) { ITERATOR result = r_find_insert_position(first, last, key); - -#ifndef NDEBUG - // Verify the result. - if (paranoid_ordered_vector) { - // If there is a node before the indicated position, this node - // must not precede it lexicograpically. - if (first < result) { - nassertr(!_compare(key, *(result - 1)), result); - } - // If there is a node after the indicated position, it must not - // precede this node lexicographically. - if (result < last) { - nassertr(!_compare(*(result), key), result); - } - } -#endif - return result; } -//////////////////////////////////////////////////////////////////// -// Function: ordered_vector::verify_list -// Access: Private -// Description: Ensures that the indicated range of elements is -// sorted correctly, if paranoid_ordered_vector is set. -// Generates an assertion failure (and returns false) if -// this is not the case; otherwise, returns true. -//////////////////////////////////////////////////////////////////// -template -INLINE bool ordered_vector:: -verify_list() { -#ifndef NDEBUG - if (paranoid_ordered_vector) { - return verify_list_impl(begin(), end()); - } -#endif - return true; -} - //////////////////////////////////////////////////////////////////// // Function: ov_set::Constructor // Access: Public @@ -771,6 +733,17 @@ sort() { ordered_vector::sort_unique(); } +//////////////////////////////////////////////////////////////////// +// Function: ov_set::verify_list +// Access: Public +// Description: Maps to verify_list_unique(). +//////////////////////////////////////////////////////////////////// +template +INLINE bool ov_set:: +verify_list() const { + return ordered_vector::verify_list_unique(); +} + //////////////////////////////////////////////////////////////////// // Function: ov_multiset::Constructor // Access: Public @@ -840,3 +813,14 @@ INLINE void ov_multiset:: sort() { ordered_vector::sort_nonunique(); } + +//////////////////////////////////////////////////////////////////// +// Function: ov_multiset::verify_list +// Access: Public +// Description: Maps to verify_list_nonunique(). +//////////////////////////////////////////////////////////////////// +template +INLINE bool ov_multiset:: +verify_list() const { + return ordered_vector::verify_list_nonunique(); +} diff --git a/panda/src/putil/ordered_vector.T b/panda/src/putil/ordered_vector.T index 4622e39243..949f813d7c 100644 --- a/panda/src/putil/ordered_vector.T +++ b/panda/src/putil/ordered_vector.T @@ -62,7 +62,6 @@ insert_unique(ordered_vector::ITERATOR position, // Otherwise, we may insert where the caller requested. ITERATOR result = _vector.insert(position, key); - verify_list(); return result; } @@ -100,10 +99,62 @@ insert_nonunique(ordered_vector::ITERATOR position, // Otherwise, we may insert where the caller requested. ITERATOR result = _vector.insert(position, key); - verify_list(); return result; } +//////////////////////////////////////////////////////////////////// +// Function: ordered_vector::verify_list_unique +// Access: Public +// Description: Ensures that the indicated range of elements is +// sorted correctly. Returns true if this is the case; +// otherwise, returns false. +//////////////////////////////////////////////////////////////////// +template +bool ordered_vector:: +verify_list_unique() const { + if (!empty()) { + CONST_ITERATOR prev = begin(); + CONST_ITERATOR i = begin(); + ++i; + while (i < end()) { + bool ordered_correctly = _compare(*prev, *i); + if (!ordered_correctly) { + return true; + } + prev = i; + ++i; + } + } + return true; +} + +//////////////////////////////////////////////////////////////////// +// Function: ordered_vector::verify_list_nonunique +// Access: Public +// Description: Ensures that the indicated range of elements is +// sorted correctly. Returns true if this is the case; +// otherwise, returns false. +//////////////////////////////////////////////////////////////////// +template +bool ordered_vector:: +verify_list_nonunique() const { + if (!empty()) { + CONST_ITERATOR prev = begin(); + CONST_ITERATOR i = begin(); + ++i; + while (i < end()) { + bool ordered_correctly = !_compare(*i, *prev); + if (!ordered_correctly) { + return true; + } + prev = i; + ++i; + } + } + return true; +} + + //////////////////////////////////////////////////////////////////// // Function: ordered_vector::r_find_insert_position // Access: Private @@ -356,28 +407,3 @@ r_equal_range(ordered_vector::CONST_ITERATOR first, return pair_type(lower, upper); } } - -#ifndef NDEBUG -//////////////////////////////////////////////////////////////////// -// Function: ordered_vector::verify_list_impl -// Access: Private -// Description: The non-inline implementation of verify_list(). -//////////////////////////////////////////////////////////////////// -template -bool ordered_vector:: -verify_list_impl(ordered_vector::ITERATOR first, - ordered_vector::ITERATOR last) { - if (first < last) { - ITERATOR prev = first; - ITERATOR i = first; - ++i; - while (i < last) { - bool ordered_correctly = !_compare(*i, *prev); - nassertr(ordered_correctly, false); - prev = i; - ++i; - } - } - return true; -} -#endif // NDEBUG diff --git a/panda/src/putil/ordered_vector.h b/panda/src/putil/ordered_vector.h index 79971dbd2a..6475fecbc4 100644 --- a/panda/src/putil/ordered_vector.h +++ b/panda/src/putil/ordered_vector.h @@ -26,53 +26,31 @@ #include "pset.h" #include -// Two different compilers that both should have known better had -// problems parsing the inheritance of typedefs in the template -// classes below. Both gcc 2.95.3 and the Intel Windows compiler (not -// sure of the version) got confused in different ways. It is a -// mystery how these compilers are able to handle the actual STL -// headers, which do this sort of thing all over the place. +// There are some inheritance issues with template classes and typedef +// names. Template classes that inherit typedef names from their base +// class, which is also a template class, may confuse the typedef +// names with globally scoped template names. In particular, the +// local "iterator" type is easily confused with the std::iterator +// template class. -// One effective workaround for both compilers seems to be to rename -// the typedef names slightly. If the following symbol is declared, -// the macros in this file will do the job of renaming the typedef -// names for these broken compilers. We should probably make this a -// configurable parameter, but since it doesn't do any harm to leave -// it declared even for non-broken compilers, we might as well just -// leave it alone. -#define BROKEN_TYPEDEF_INHERITANCE 1 +// To work around this problem, as well as a problem in gcc 2.95.3 +// with value_type etc. not inheriting properly (even though we +// explicitly typedef them in the derived class), we rename the +// questionable typedefs here so that they no longer conflict with the +// global template classes. -// Maybe eventually, when STL is more than only about ten years old -// and compiler support of anything more than trivial template classes -// is more universal, we can pull this nonsense out of here. - -#ifdef BROKEN_TYPEDEF_INHERITANCE - #define KEY_TYPE key_type_0 - #define VALUE_TYPE value_type_0 - #define REFERENCE reference_0 - #define CONST_REFERENCE const_reference_0 - #define KEY_COMPARE key_compare_0 - #define VALUE_COMPARE value_compare_0 - #define ITERATOR iterator_0 - #define CONST_ITERATOR const_iterator_0 - #define REVERSE_ITERATOR reverse_iterator_0 - #define CONST_REVERSE_ITERATOR const_reverse_iterator_0 - #define DIFFERENCE_TYPE difference_type_0 - #define SIZE_TYPE size_type_0 -#else - #define KEY_TYPE key_type - #define VALUE_TYPE value_type - #define REFERENCE reference - #define CONST_REFERENCE const_reference - #define KEY_COMPARE key_compare - #define VALUE_COMPARE value_compare - #define ITERATOR iterator - #define CONST_ITERATOR const_iterator - #define REVERSE_ITERATOR reverse_iterator - #define CONST_REVERSE_ITERATOR const_reverse_iterator - #define DIFFERENCE_TYPE difference_type - #define SIZE_TYPE size_type -#endif +#define KEY_TYPE key_type_0 +#define VALUE_TYPE value_type_0 +#define REFERENCE reference_0 +#define CONST_REFERENCE const_reference_0 +#define KEY_COMPARE key_compare_0 +#define VALUE_COMPARE value_compare_0 +#define ITERATOR iterator_0 +#define CONST_ITERATOR const_iterator_0 +#define REVERSE_ITERATOR reverse_iterator_0 +#define CONST_REVERSE_ITERATOR const_reverse_iterator_0 +#define DIFFERENCE_TYPE difference_type_0 +#define SIZE_TYPE size_type_0 //////////////////////////////////////////////////////////////////// // Class : ordered_vector @@ -135,7 +113,6 @@ public: typedef Vector::difference_type DIFFERENCE_TYPE; typedef Vector::size_type SIZE_TYPE; -#ifdef BROKEN_TYPEDEF_INHERITANCE // Since the #define symbols do not actually expand to the correct // names, we have to re-typedef them so callers can reference them // by their correct, lowercase names. @@ -151,7 +128,6 @@ public: typedef CONST_REVERSE_ITERATOR const_reverse_iterator; typedef DIFFERENCE_TYPE difference_type; typedef SIZE_TYPE size_type; -#endif public: // Constructors. We don't implement the whole slew of STL @@ -221,6 +197,8 @@ public: INLINE void reserve(SIZE_TYPE n); INLINE void sort_unique(); INLINE void sort_nonunique(); + bool verify_list_unique() const; + bool verify_list_nonunique() const; INLINE void push_back(const VALUE_TYPE &key); @@ -245,11 +223,6 @@ private: pair r_equal_range(CONST_ITERATOR first, CONST_ITERATOR last, const KEY_TYPE &key) const; - INLINE bool verify_list(); - -#ifndef NDEBUG - bool verify_list_impl(ITERATOR first, ITERATOR last); -#endif // This function object is used in sort_unique(). It returns true // if two consecutive sorted elements are equivalent. @@ -290,6 +263,7 @@ public: INLINE pair insert(const VALUE_TYPE &key0); INLINE void sort(); + INLINE bool verify_list() const; }; //////////////////////////////////////////////////////////////////// @@ -309,6 +283,7 @@ public: INLINE ITERATOR insert(const VALUE_TYPE &key); INLINE void sort(); + INLINE bool verify_list() const; }; #include "ordered_vector.I"