songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Trying to fix the compilation warning we get from gcc 4.1

This commit is contained in:
Ron Wein 2006-02-23 13:08:30 +00:00
parent 80a2a418a0
commit fdd566b269
1 changed files with 52 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
STL_Extension/include/CGAL/Compact_container.h
View File

@ -673,85 +673,99 @@ namespace CGALi {
typedef std::bidirectional_iterator_tag iterator_category; typedef std::bidirectional_iterator_tag iterator_category;
// the initialization with NULL is required by our Handle concept. // the initialization with NULL is required by our Handle concept.
CC_iterator() : p(NULL) {} CC_iterator()
{
m_ptr.p = NULL;
}
// Either a harmless copy-ctor, // Either a harmless copy-ctor,
// or a conversion from iterator to const_iterator. // or a conversion from iterator to const_iterator.
CC_iterator(const iterator &it) CC_iterator (const iterator &it)
: p(&*it) {} {
m_ptr.p = &(*it);
}
// Same for assignment operator (otherwise MipsPro warns) // Same for assignment operator (otherwise MipsPro warns)
CC_iterator & operator=(const iterator &it) CC_iterator & operator= (const iterator &it)
{ {
p = it.p; m_ptr.p = &(*it);
return *this; return *this;
} }
// Construction from NULL // Construction from NULL
CC_iterator(CGAL_NULL_TYPE CGAL_assertion_code(n)) CC_iterator (CGAL_NULL_TYPE CGAL_assertion_code(n))
: p(NULL)
{ {
CGAL_assertion( n == NULL); CGAL_assertion (n == NULL);
m_ptr.p = NULL;
} }
private: private:
pointer p; union {
pointer p;
void *vp;
} m_ptr;
// Only Compact_container should access these constructors. // Only Compact_container should access these constructors.
friend class Compact_container<value_type, typename DSC::Al>; friend class Compact_container<value_type, typename DSC::Al>;
// For begin() // For begin()
CC_iterator(pointer ptr, int, int) CC_iterator(pointer ptr, int, int)
: p(ptr)
{ {
if (p == NULL) // empty container. m_ptr.p = ptr;
if (m_ptr.p == NULL) // empty container.
return; return;
++p; // if not empty, p = start
if (DSC::type(p) == DSC::FREE) ++(m_ptr.p); // if not empty, p = start
if (DSC::type(m_ptr.p) == DSC::FREE)
increment(); increment();
} }
// Construction from raw pointer and for end(). // Construction from raw pointer and for end().
CC_iterator(pointer ptr, int) CC_iterator(pointer ptr, int)
: p(ptr) {} {
m_ptr.p = ptr;
}
// NB : in case empty container, begin == end == NULL. // NB : in case empty container, begin == end == NULL.
void increment() void increment()
{ {
// It's either pointing to end(), or valid. // It's either pointing to end(), or valid.
CGAL_assertion_msg(p != NULL, CGAL_assertion_msg(m_ptr.p != NULL,
"Doing ++ on empty container iterator ?"); "Doing ++ on empty container iterator ?");
CGAL_assertion_msg(DSC::type(p) != DSC::START_END, CGAL_assertion_msg(DSC::type(m_ptr.p) != DSC::START_END,
"Doing ++ on end() ?"); "Doing ++ on end() ?");
// If it's not end(), then it's valid, we can do ++. // If it's not end(), then it's valid, we can do ++.
do { do {
++p; ++(m_ptr.p);
if (DSC::type(p) == DSC::USED || if (DSC::type(m_ptr.p) == DSC::USED ||
DSC::type(p) == DSC::START_END) DSC::type(m_ptr.p) == DSC::START_END)
return; return;
if (DSC::type(p) == DSC::BLOCK_BOUNDARY)
p = DSC::clean_pointee(p); if (DSC::type(m_ptr.p) == DSC::BLOCK_BOUNDARY)
} m_ptr.p = DSC::clean_pointee(m_ptr.p);
while (true); } while (true);
} }
void decrement() void decrement()
{ {
// It's either pointing to end(), or valid. // It's either pointing to end(), or valid.
CGAL_assertion_msg(p != NULL, CGAL_assertion_msg(m_ptr.p != NULL,
"Doing -- on empty container iterator ?"); "Doing -- on empty container iterator ?");
CGAL_assertion_msg(DSC::type(p-1) != DSC::START_END, CGAL_assertion_msg(DSC::type(m_ptr.p - 1) != DSC::START_END,
"Doing -- on begin() ?"); "Doing -- on begin() ?");
// If it's not begin(), then it's valid, we can do --. // If it's not begin(), then it's valid, we can do --.
do { do {
--p; --m_ptr.p;
if (DSC::type(p) == DSC::USED || if (DSC::type(m_ptr.p) == DSC::USED ||
DSC::type(p) == DSC::START_END) DSC::type(m_ptr.p) == DSC::START_END)
return; return;
if (DSC::type(p) == DSC::BLOCK_BOUNDARY)
p = DSC::clean_pointee(p); if (DSC::type(m_ptr.p) == DSC::BLOCK_BOUNDARY)
} m_ptr.p = DSC::clean_pointee(m_ptr.p);
while (true); } while (true);
} }
public: public:
@ -762,18 +776,19 @@ namespace CGALi {
Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; }
Self operator--(int) { Self tmp(*this); --(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; }
reference operator*() const { return *p; } reference operator*() const { return *(m_ptr.p); }
pointer operator->() const { return p; }
pointer operator->() const { return (m_ptr.p); }
// For std::less... // For std::less...
bool operator<(const CC_iterator& other) const bool operator<(const CC_iterator& other) const
{ {
return p < other.p; return (m_ptr.p < other.m_ptr.p);
} }
// Can itself be used for bit-squatting. // Can itself be used for bit-squatting.
void * for_compact_container() const { return (void *) p; } void * for_compact_container() const { return (m_ptr.vp); }
void * & for_compact_container() { return (void * &) p; } void * & for_compact_container() { return (m_ptr.vp); }
}; };
template < class DSC, bool Const1, bool Const2 > template < class DSC, bool Const1, bool Const2 >