SPAR/AIModule/BWTA/vendors/CGAL/CGAL/Tools/utility_macros.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	CGAL_SUBSCRIPT(type, expr)
#define	CGAL_COPY_CONSTRUCTOR(TC)
#define	CGAL_GET(type, name, expr)   const type & name() const{expr;}
#define	CGAL_GETOBJECT(UC, lc, expr)   const UC& lc##_object() const {expr;}
#define	CGAL_GETNR(type, name, expr)   type name() const{expr;}
#define	CGAL_IS(name, expr)   bool is_##name() const {expr;}
#define	CGAL_SET_IS(name, expr)   void set_is_##name(bool tf) {expr;}
#define	CGAL_SET(type, name, expr)   void set_##name(const type &k) {expr;}
#define	CGAL_GETSET(type, name, var)
#define	CGAL_OUTPUT(type)
#define	CGAL_OUTPUT1(type)
#define	CGAL_OUTPUT2(T)
#define	CGAL_ITERATOR(uc_name, lc_name, const_it_type, it_type, bexpr, eexpr)
#define	CGAL_CONST_ITERATOR(uc_name, lc_name, it_type, bexpr, eexpr)
#define	CGAL_CONST_FIND(ucname, fexpr, expr)
#define	CGAL_FIND(ucname, fexpr, eexpr)
#define	CGAL_INSERT(ucname, expr)   void insert(ucname##_key k, const ucname &m) {expr;}
#define	CGAL_INSERTNK(ucname, expr)   void insert(const ucname &m) {expr;}
#define	CGAL_SWAP(type)
#define	CGAL_SWAP1(type)
#define	CGAL_SWAP2(type)
#define	CGAL_ISWAP(name)   std::swap(name, o.name)
#define	CGAL_IFNONEQUAL(a, b, cmp)
#define	CGAL_COMPARISONS
#define	CGAL_COMPARISONS_COMPARE
#define	CGAL_COMPARISONS1(field)
#define	CGAL_COMPARISONS2(a, b)
#define	CGAL_COMPARISONS3(a, b, c)
#define	CGAL_REAL_EMBEDDABLE_BODY
#define	CGAL_HAS_INFINITY_BODY
#define	CGAL_REAL_EMBEDDABLE1(name)
#define	CGAL_REAL_EMBEDDABLE2(name)
#define	CGAL_HAS_INFINITY1(name)
#define	CGAL_REAL_EMBEDABLE2(name)
#define	CGAL_HAS_INFINITY2(name)

---

Define Documentation

#define CGAL_COMPARISONS

Value:

bool operator==(const This &o) const {          \
    return compare(o) == CGAL::EQUAL;                                   \
  }                                                                     \
  bool operator!=(const This &o) const {                                \
    return compare(o) != CGAL::EQUAL;                                   \
  }                                                                     \
  bool operator<(const This &o) const {                                 \
    return compare(o) == CGAL::SMALLER;                                 \
  }                                                                     \
  bool operator>(const This &o) const {                                 \
    return compare(o) == CGAL::LARGER;                                  \
  }                                                                     \
  bool operator>=(const This &o) const {                                \
    return compare(o) != CGAL::SMALLER;                                 \
  }                                                                     \
  bool operator<=(const This &o) const {                                \
    return compare(o) != CGAL::LARGER;                                  \
  }

#define CGAL_COMPARISONS1

(

field

)

Value:

bool operator==(const This &o) const { \
    return (field== o.field);                                           \
  }                                                                     \
  bool operator!=(const This &o) const {                                \
    return (field!= o.field);                                           \
  }                                                                     \
  bool operator<(const This &o) const {                                 \
    return (field< o.field);                                            \
  }                                                                     \
  bool operator>(const This &o) const {                                 \
    return (field> o.field);                                            \
  }                                                                     \
  bool operator>=(const This &o) const {                                \
    return (field>= o.field);                                           \
  }                                                                     \
  bool operator<=(const This &o) const {                                \
    return (field<= o.field);                                           \
  }

#define CGAL_COMPARISONS2	(		a,
			b
	)

Value:

bool operator==(const This &o) const {  \
    return (a== o.a && b== o.b);                                        \
  }                                                                     \
  bool operator!=(const This &o) const {                                \
    return (a!= o.a || b != o.b);                                       \
  }                                                                     \
  bool operator<(const This &o) const {                                 \
    if (a< o.a ) return true;                                           \
    else if (a > o.a) return false;                                     \
    else return b < o.b;                                                \
  }                                                                     \
  bool operator>(const This &o) const {                                 \
    if (a> o.a ) return true;                                           \
    else if (a < o.a) return false;                                     \
    else return b > o.b;                                                \
  }                                                                     \
  bool operator>=(const This &o) const {                                \
    return !operator<(o);                                               \
  }                                                                     \
  bool operator<=(const This &o) const {                                \
    return !operator>(o);                                               \
  }

#define CGAL_COMPARISONS3	(		a,
			b,
			c
	)

Value:

bool operator==(const This &o) const {                          \
    return (a== o.a && b== o.b && c == o.c);                            \
  }                                                                     \
  bool operator!=(const This &o) const {                                \
    return (a!= o.a || b != o.b || c != o.c);                           \
  }                                                                     \
  bool operator<(const This &o) const {                                 \
    if (a < o.a ) return true;                                          \
    else if (a > o.a) return false;                                     \
    else if (b < o.b) return true;                                      \
    else if (b > o.b) return false;                                     \
    else return c < o.c;                                                \
  }                                                                     \
  bool operator>(const This &o) const {                                 \
    if (a > o.a ) return true;                                          \
    else if (a < o.a) return false;                                     \
    else if (b > o.b) return true;                                      \
    else if (b < o.b) return false;                                     \
    else return c > o.c;                                                \
  }                                                                     \
  bool operator>=(const This &o) const {                                \
    return !operator<(o);                                               \
  }                                                                     \
  bool operator<=(const This &o) const {                                \
    return !operator>(o);                                               \
  }

#define CGAL_COMPARISONS_COMPARE

Value:

bool operator==(const This &o) const { \
    return compare(o)==0;                                               \
  }                                                                     \
  bool operator!=(const This &o) const {                                \
    return compare(o)!=0;                                               \
  }                                                                     \
  bool operator<(const This &o) const {                                 \
    return compare(o) < 0;                                              \
  }                                                                     \
  bool operator>(const This &o) const {                                 \
    return compare(o) > 0;                                              \
  }                                                                     \
  bool operator>=(const This &o) const {                                \
    return compare(o) >=0;                                              \
  }                                                                     \
  bool operator<=(const This &o) const {                                \
    return compare(o) <= 0;                                             \
  }

#define CGAL_CONST_FIND	(		ucname,
			fexpr,
			expr
	)

Value:

bool contains(ucname##_key k) const {                            \
    return fexpr != eexpr;                                         \
  }                                                                \
  std::iterator_traits<ucname##s::iterator>::value_type get(ucname##_key k) const {      \
    CGAL_assertion(contains(k));                                   \
    return *fexpr;                                                 \
  }                                                                \
  ucname##s::const_iterator find(ucname##_key k) {                 \
    return fexpr;                                                  \
  }

#define CGAL_CONST_ITERATOR	(		uc_name,
			lc_name,
			it_type,
			bexpr,
			eexpr
	)

Value:

typedef boost::iterator_range< it_type > uc_name##s;                  \
  uc_name##s lc_name##s() const {                                       \
    return uc_name##s(bexpr, eexpr);                                    \
  }

#define CGAL_COPY_CONSTRUCTOR

(

TC

)

Value:

TC(const TC &o){copy_from(o);}\
  TC& operator=(const TC &o) {copy_from(o); return *this;}

#define CGAL_FIND	(		ucname,
			fexpr,
			eexpr
	)

Value:

bool contains(ucname##_key k) const {                         \
    return fexpr != eexpr;                                      \
  }                                                             \
  std::iterator_traits< ucname##s::iterator >::reference get(ucname##_key k) { \
    CGAL_assertion(contains(k));                                \
    return *fexpr;                                              \
  }                                                             \
  ucname##s::iterator find(ucname##_key k) {                    \
    return fexpr;                                               \
  }                                                             \
  std::iterator_traits< ucname##s::const_iterator >::value_type get(ucname##_key k) const {      \
    CGAL_assertion(contains(k));                                   \
    return *fexpr;                                                 \
  }                                                                \
  ucname##_consts::const_iterator find(ucname##_key k) const {           \
    return fexpr;                                                  \
  }

#define CGAL_GET	(		type,
			name,
			expr
	)		const type & name() const{expr;}

#define CGAL_GETNR	(		type,
			name,
			expr
	)		type name() const{expr;}

#define CGAL_GETOBJECT	(		UC,
			lc,
			expr
	)		const UC& lc##_object() const {expr;}

#define CGAL_GETSET	(		type,
			name,
			var
	)

Value:

CGAL_GET(type, name, return var)              \
  CGAL_SET(type, name, var = k)

#define CGAL_HAS_INFINITY1

(

name

)

Value:

namespace std                                                           \
  {                                                                     \
    template <class Tr>                                                 \
      class numeric_limits<name<Tr> >                                   \
    {                                                                   \
    public:                                                             \
      typedef name<Tr> T;                                               \
      CGAL_HAS_INFINITY_BODY;                                           \
    };                                                                  \
  };

#define CGAL_HAS_INFINITY2

(

name

)

Value:

namespace std                                                           \
  {                                                                     \
    template <class Tr, class Ur>                                       \
      class numeric_limits<name<Tr, Ur> >                               \
    {                                                                   \
    public:                                                             \
      typedef name<Tr, Ur> T;                                           \
      CGAL_HAS_INFINITY_BODY;                                           \
    };                                                                  \
  };

#define CGAL_HAS_INFINITY_BODY

#define CGAL_IFNONEQUAL	(		a,
			b,
			cmp
	)

Value:

if (a cmp b) return true;       \
  else if (b cmp a) return false

#define CGAL_INSERT	(		ucname,
			expr
	)		void insert(ucname##_key k, const ucname &m) {expr;}

#define CGAL_INSERTNK	(		ucname,
			expr
	)		void insert(const ucname &m) {expr;}

#define CGAL_IS	(		name,
			expr
	)		bool is_##name() const {expr;}

#define CGAL_ISWAP

(

name

)

std::swap(name, o.name)

#define CGAL_ITERATOR	(		uc_name,
			lc_name,
			const_it_type,
			it_type,
			bexpr,
			eexpr
	)

Value:

typedef boost::iterator_range< it_type > uc_name##s;                  \
  uc_name##s lc_name##s() {                                             \
    return uc_name##s(it_type(bexpr), it_type(eexpr));                  \
  }                                                                     \
  typedef boost::iterator_range< const_it_type > uc_name##_consts;      \
  uc_name##_consts lc_name##s() const {                                 \
    return uc_name##_consts(const_it_type(bexpr), const_it_type(eexpr)); \
  }

#define CGAL_OUTPUT

(

type

)

Value:

inline std::ostream& operator<<(std::ostream&out, const type &t){       \
    return t.write(out);                                                \
  }

#define CGAL_OUTPUT1

(

type

)

Value:

template <class A>                                                      \
  inline std::ostream& operator<<(std::ostream&out, const type<A> &t){  \
    return t.write(out);                                                \
  }

#define CGAL_OUTPUT2

(

T

)

Value:

template <class A, class B>                                             \
  inline std::ostream& operator<<(std::ostream&out, const T<A,B> &t){   \
    return t.write(out);                                                \
  }

#define CGAL_REAL_EMBEDABLE2

(

name

)

Value:

CGAL_BEGIN_NAMESPACE                                                    \
  template <class T,class U>                                            \
  class Real_embeddable_traits< name<T, U> >                            \
    : public INTERN_RET::Real_embeddable_traits_base< name<T, U> , Tag_true>{ \
  public:                                                               \
    typedef name<T, U>  Type;                                           \
    CGAL_REAL_EMBEDDABLE_BODY                                           \
  };                                                                    \
  CGAL_END_NAMESPACE

#define CGAL_REAL_EMBEDDABLE1

(

name

)

Value:

CGAL_BEGIN_NAMESPACE                                                    \
  template <class T>                                                    \
  class Real_embeddable_traits< name<T> >                               \
    : public INTERN_RET::Real_embeddable_traits_base<name<T>, Tag_true>{ \
  public:                                                               \
    typedef name<T>  Type;                                              \
    CGAL_REAL_EMBEDDABLE_BODY;                                          \
  };                                                                    \
  CGAL_END_NAMESPACE

#define CGAL_REAL_EMBEDDABLE2

(

name

)

Value:

CGAL_BEGIN_NAMESPACE                                                    \
  template <class T, class A>                                           \
  class Real_embeddable_traits< name<T, A> >                            \
    : public INTERN_RET::Real_embeddable_traits_base< name<T, A>, Tag_true>{ \
  public:                                                               \
    typedef name<T, A>  Type;                                           \
    CGAL_REAL_EMBEDDABLE_BODY;                                          \
  };                                                                    \
  CGAL_END_NAMESPACE

#define CGAL_REAL_EMBEDDABLE_BODY

#define CGAL_SET	(		type,
			name,
			expr
	)		void set_##name(const type &k) {expr;}

#define CGAL_SET_IS	(		name,
			expr
	)		void set_is_##name(bool tf) {expr;}

#define CGAL_SUBSCRIPT	(		type,
			expr
	)

Value:

type& operator[](unsigned int i){ expr;} \
  const type& operator[](unsigned int i) const { expr;}

#define CGAL_SWAP

(

type

)

Value:

inline void swap(type &a, type &b) {            \
    a.swap_with(b);                             \
  }

#define CGAL_SWAP1

(

type

)

Value:

template <class A>                              \
 inline void swap(type<A> &a, type<A> &b) {     \
    a.swap_with(b);                             \
  }

#define CGAL_SWAP2

(

type

)

Value:

template <class A, class B>                     \
 inline void swap(type<A,B> &a, type<A,B> &b) { \
    a.swap_with(b);                             \
  }