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

523 lines
19 KiB
C++
Raw Blame History

// ======================================================================
//
// Copyright (c) 2001 The CGAL Consortium
//
// This software and related documentation is part of an INTERNAL release
// of the Computational Geometry Algorithms Library (CGAL). It is not
// intended for general use.
//
// ----------------------------------------------------------------------
//
// release :
// release_date :
//
// file : include/CGAL/Kernel_checker.h
// package :
// maintainer :
// revision : $Id$
// revision_date : $Date$
// author(s) :
// coordinator :
//
// ======================================================================
#ifndef CGAL_KERNEL_CHECKER_H
#define CGAL_KERNEL_CHECKER_H
#include <CGAL/basic.h>
#include <CGAL/multirep.h>
#include <utility>
#include <iostream>
CGAL_BEGIN_NAMESPACE
// Class used by Kernel_checker.
template <class O1, class O2,
class Conv>
class Special_construction
{
O1 o1;
O2 o2;
public:
Special_construction(const O1 &oo1 = O1(), const O2 &oo2 = O2())
: o1(oo1), o2(oo2) {}
// we have another result type now ...
typedef MultiRep<typename O1::result_type, typename O2::result_type, Conv> result_type;
// the arity can stay ...
typedef typename O1::Arity Arity;
// --------------------------------------------------------------------------------
// attention: we have to handle MultiRep arguments in the templated
// operators, but also other stuff (for instance ints in Construct_vertex)
// problem: does this work on VC++ ?
template<class FR, class SR, class Converter>
const FR& get_first_rep(const MultiRep<FR,SR,Converter>& obj) const
{ return obj.get_first_rep(); }
template<class T>
const T& get_first_rep(const T& other_obj) const
{ return other_obj; }
template<class FR, class SR, class Converter>
const SR& get_second_rep(const MultiRep<FR,SR,Converter>& obj) const
{ return obj.get_second_rep(); }
template<class T>
const T& get_second_rep(const T& other_obj) const
{ return other_obj; }
// --------------------------------------------------------------------------------
template <class A1>
result_type
operator()(const A1 &a1) const
{
// construct the two representations ...
typename O1::result_type res1 = o1(get_first_rep(a1));
typename O2::result_type res2 = o2(get_second_rep(a1));
// should we add some kind of check here as well ?
// we use the special constructor here ...
return result_type(res1, res2);
}
template <class A1, class A2>
result_type
operator()(const A1 &a1, const A2 &a2) const
{
// construct the two representations ...
typename O1::result_type res1 = o1(get_first_rep(a1), get_first_rep(a2));
typename O2::result_type res2 = o2(get_second_rep(a1), get_second_rep(a2));
// should we add some kind of check here as well ?
// we use the special constructor here ...
return result_type(res1, res2);
}
template <class A1, class A2, class A3>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3) const
{
// construct the two representations ...
typename O1::result_type res1 = o1(get_first_rep(a1), get_first_rep(a2), get_first_rep(a3));
typename O2::result_type res2 = o2(get_second_rep(a1), get_second_rep(a2), get_second_rep(a3));
// should we add some kind of check here as well ?
// we use the special constructor here ...
return result_type(res1, res2);
}
template <class A1, class A2, class A3, class A4>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const
{
// construct the two representations ...
typename O1::result_type res1 = o1(get_first_rep(a1), get_first_rep(a2),
get_first_rep(a3), get_first_rep(a4));
typename O2::result_type res2 = o2(get_second_rep(a1), get_second_rep(a2),
get_second_rep(a3), get_second_rep(a4));
// should we add some kind of check here as well ?
// we use the special constructor here ...
return result_type(res1, res2);
}
template <class A1, class A2, class A3, class A4, class A5>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5) const
{
// construct the two representations ...
typename O1::result_type res1 = o1(get_first_rep(a1), get_first_rep(a2),
get_first_rep(a3), get_first_rep(a4), get_first_rep(a5));
typename O2::result_type res2 = o2(get_second_rep(a1), get_second_rep(a2),
get_second_rep(a3), get_second_rep(a4), get_second_rep(a5));
// should we add some kind of check here as well ?
// we use the special constructor here ...
return result_type(res1, res2);
}
template <class A1, class A2, class A3, class A4, class A5, class A6>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6) const
{
// construct the two representations ...
typename O1::result_type res1 = o1(get_first_rep(a1), get_first_rep(a2),
get_first_rep(a3), get_first_rep(a4),
get_first_rep(a5), get_first_rep(a6));
typename O2::result_type res2 = o2(get_second_rep(a1), get_second_rep(a2),
get_second_rep(a3), get_second_rep(a4),
get_second_rep(a5), get_second_rep(a6));
// should we add some kind of check here as well ?
// we use the special constructor here ...
return result_type(res1, res2);
}
template <class A1, class A2, class A3, class A4, class A5,class A6,class A7>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7) const
{
// construct the two representations ...
typename O1::result_type res1 = o1(get_first_rep(a1), get_first_rep(a2),
get_first_rep(a3), get_first_rep(a4),
get_first_rep(a5), get_first_rep(a6),
get_first_rep(a7));
typename O2::result_type res2 = o2(get_second_rep(a1), get_second_rep(a2),
get_second_rep(a3), get_second_rep(a4),
get_second_rep(a5), get_second_rep(a6),
get_second_rep(a7));
// should we add some kind of check here as well ?
// we use the special constructor here ...
return result_type(res1, res2);
}
template <class A1, class A2, class A3, class A4,
class A5, class A6, class A7, class A8>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8) const
{
// construct the two representations ...
typename O1::result_type res1 = o1(get_first_rep(a1), get_first_rep(a2),
get_first_rep(a3), get_first_rep(a4),
get_first_rep(a5), get_first_rep(a6),
get_first_rep(a7), get_first_rep(a8));
typename O2::result_type res2 = o2(get_second_rep(a1), get_second_rep(a2),
get_second_rep(a3), get_second_rep(a4),
get_second_rep(a5), get_second_rep(a6),
get_second_rep(a7), get_second_rep(a8));
// should we add some kind of check here as well ?
// we use the special constructor here ...
return result_type(res1, res2);
}
// Same thing with more arguments...
};
// Class used by Kernel_checker.
template <class O1, class O2>
class Predicate_checker
{
O1 o1;
O2 o2;
public:
Predicate_checker(const O1 &oo1 = O1(), const O2 &oo2 = O2())
: o1(oo1), o2(oo2) {}
// the result type and arity of predicates can stay ...
typedef typename O1::result_type result_type;
typedef typename O1::Arity Arity;
template <class A1>
result_type
operator()(const A1 &a1) const
{
#if defined(CGAL_KCH_DEBUG)
std::cout << "Predicate_checker(1):";
a1.output(std::cout);
std::cout << "\n";
#endif
typename O1::result_type res1 = o1(a1);
typename O2::result_type res2 = o2(a1.get_second_rep());
if (res1 != res2)
{
std::cerr << "Kernel_checker error : " << res1 << " != " << res2
<< " for the inputs : " << std::endl;
std::cerr << a1 << std::endl;
#ifdef __GNUG__
std::cerr << __PRETTY_FUNCTION__ << std::endl;
#endif
CGAL_kernel_assertion(false);
}
return res1;
}
template <class A1, class A2>
result_type
operator()(const A1 &a1, const A2 &a2) const
{
#if defined(CGAL_KCH_DEBUG)
std::cout << "Predicate_checker(2):";
a1.output(std::cout);
a2.output(std::cout);
std::cout << "\n";
#endif
typename O1::result_type res1 = o1(a1, a2);
typename O2::result_type res2 = o2(a1.get_second_rep(), a2.get_second_rep());
if (res1 != res2)
{
std::cerr << "Kernel_checker error : " << res1 << " != " << res2
<< " for the inputs : " << std::endl;
std::cerr << a1 << ", " << a2 << std::endl;
#ifdef __GNUG__
std::cerr << __PRETTY_FUNCTION__ << std::endl;
#endif
CGAL_kernel_assertion(false);
}
return res1;
}
template <class A1, class A2, class A3>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3) const
{
#if defined(CGAL_KCH_DEBUG)
std::cout << "Predicate_checker(3):";
a1.output(std::cout); a2.output(std::cout); a3.output(std::cout);
std::cout << "\n";
#endif
typename O1::result_type res1 = o1(a1, a2, a3);
typename O2::result_type res2 = o2(a1.get_second_rep(), a2.get_second_rep(),
a3.get_second_rep());
if (res1 != res2)
{
std::cerr << "Kernel_checker error : " << res1 << " != " << res2
<< " for the inputs : " << std::endl;
std::cerr << a1 << ", " << a2 << ", " << a3 << std::endl;
#ifdef __GNUG__
std::cerr << __PRETTY_FUNCTION__ << std::endl;
#endif
CGAL_kernel_assertion(false);
}
return res1;
}
template <class A1, class A2, class A3, class A4>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const
{
#if defined(CGAL_KCH_DEBUG)
std::cout << "Predicate_checker(4):";
a1.output(std::cout); a2.output(std::cout);
a3.output(std::cout); a4.output(std::cout);
#endif
typename O1::result_type res1 = o1(a1, a2, a3, a4);
typename O2::result_type res2 = o2(a1.get_second_rep(), a2.get_second_rep(),
a3.get_second_rep(), a4.get_second_rep());
if (res1 != res2)
{
std::cerr << "Kernel_checker error : " << res1 << " != " << res2
<< " for the inputs : " << std::endl;
std::cerr << a1 << ", " << a2 << ", " << a3 << ", " << a4
<< std::endl;
#ifdef __GNUG__
std::cerr << __PRETTY_FUNCTION__ << std::endl;
#endif
CGAL_kernel_assertion(false);
}
return res1;
}
template <class A1, class A2, class A3, class A4, class A5>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5) const
{
typename O1::result_type res1 = o1(a1, a2, a3, a4, a5);
typename O2::result_type res2 = o2(a1.get_second_rep(), a2.get_second_rep(),
a3.get_second_rep(), a4.get_second_rep(),
a5.get_second_rep());
if (res1 != res2)
{
std::cerr << "Kernel_checker error : " << res1 << " != " << res2
<< " for the inputs : " << std::endl;
std::cerr << a1 << ", " << a2 << ", " << a3 << ", " << a4
<< ", " << a5 << std::endl;
#ifdef __GNUG__
std::cerr << __PRETTY_FUNCTION__ << std::endl;
#endif
CGAL_kernel_assertion(false);
}
return res1;
}
template <class A1, class A2, class A3, class A4, class A5, class A6>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6) const
{
typename O1::result_type res1 = o1(a1, a2, a3, a4, a5, a6);
typename O2::result_type res2 = o2(a1.get_second_rep(), a2.get_second_rep(),
a3.get_second_rep(), a4.get_second_rep(),
a5.get_second_rep(), a6.get_second_rep());
if (res1 != res2)
{
std::cerr << "Kernel_checker error : " << res1 << " != " << res2
<< " for the inputs : " << std::endl;
std::cerr << a1 << ", " << a2 << ", " << a3 << ", " << a4
<< ", " << a5 << std::endl;
#ifdef __GNUG__
std::cerr << __PRETTY_FUNCTION__ << std::endl;
#endif
CGAL_kernel_assertion(false);
}
return res1;
}
// Same thing with more arguments...
};
// offer the ability to use different converters for different objects ...
// (might be important for some traits classes with vector type = direction type ?)
template<class Converter>
struct Default_converter_traits {
typedef Converter Converter_object_2;
typedef Converter Converter_object_3;
typedef Converter Converter_point_2;
typedef Converter Converter_vector_2;
typedef Converter Converter_direction_2;
typedef Converter Converter_line_2;
typedef Converter Converter_ray_2;
typedef Converter Converter_segment_2;
typedef Converter Converter_triangle_2;
typedef Converter Converter_circle_2;
typedef Converter Converter_iso_rectangle_2;
typedef Converter Converter_point_3;
typedef Converter Converter_vector_3;
typedef Converter Converter_direction_3;
typedef Converter Converter_line_3;
typedef Converter Converter_plane_3;
typedef Converter Converter_ray_3;
typedef Converter Converter_segment_3;
typedef Converter Converter_triangle_3;
typedef Converter Converter_tetrahedron_3;
typedef Converter Converter_sphere_3;
typedef Converter Converter_iso_cuboid_3;
};
// For now, we inherit all geometric objects and constructions from K1, and
// just overload the predicates.
template <class K1, class K2,
class Conv>
class Kernel_checker
: public K1
{
typedef K1 Kernel1;
typedef K2 Kernel2;
Kernel2 k2;
typedef Conv c;
// the FT/RT stuff is still a problem ...
// we derive it at the moment from K1
// get the conversion functors from Conv ...
public:
typedef typename Conv::Converter_object_2 Converter_object_2;
typedef typename Conv::Converter_object_3 Converter_object_3;
typedef typename Conv::Converter_point_2 Converter_point_2;
typedef typename Conv::Converter_vector_2 Converter_vector_2;
typedef typename Conv::Converter_direction_2 Converter_direction_2;
typedef typename Conv::Converter_line_2 Converter_line_2;
typedef typename Conv::Converter_ray_2 Converter_ray_2;
typedef typename Conv::Converter_segment_2 Converter_segment_2;
typedef typename Conv::Converter_triangle_2 Converter_triangle_2;
typedef typename Conv::Converter_circle_2 Converter_circle_2;
typedef typename Conv::Converter_iso_rectangle_2 Converter_iso_rectangle_2;
typedef typename Conv::Converter_point_3 Converter_point_3;
typedef typename Conv::Converter_vector_3 Converter_vector_3;
typedef typename Conv::Converter_direction_3 Converter_direction_3;
typedef typename Conv::Converter_line_3 Converter_line_3;
typedef typename Conv::Converter_plane_3 Converter_plane_3;
typedef typename Conv::Converter_ray_3 Converter_ray_3;
typedef typename Conv::Converter_segment_3 Converter_segment_3;
typedef typename Conv::Converter_triangle_3 Converter_triangle_3;
typedef typename Conv::Converter_tetrahedron_3 Converter_tetrahedron_3;
typedef typename Conv::Converter_sphere_3 Converter_sphere_3;
typedef typename Conv::Converter_iso_cuboid_3 Converter_iso_cuboid_3;
// now the typedefs; we use the MultiRep class template ...
typedef CGAL::MultiRep<typename K1::Object_2,typename K2::Object_2, Converter_object_2> Object_2;
typedef CGAL::MultiRep<typename K1::Object_3,typename K2::Object_3, Converter_object_3> Object_3;
typedef CGAL::MultiRep<typename K1::Point_2,typename K2::Point_2, Converter_point_2> Point_2;
typedef CGAL::MultiRep<typename K1::Vector_2,typename K2::Vector_2, Converter_vector_2> Vector_2;
typedef CGAL::MultiRep<typename K1::Direction_2,typename K2::Direction_2, Converter_direction_2> Direction_2;
typedef CGAL::MultiRep<typename K1::Line_2,typename K2::Line_2, Converter_line_2> Line_2;
typedef CGAL::MultiRep<typename K1::Ray_2,typename K2::Ray_2, Converter_ray_2> Ray_2;
typedef CGAL::MultiRep<typename K1::Segment_2,typename K2::Segment_2, Converter_segment_2> Segment_2;
typedef CGAL::MultiRep<typename K1::Triangle_2,typename K2::Triangle_2, Converter_triangle_2> Triangle_2;
typedef CGAL::MultiRep<typename K1::Circle_2,typename K2::Circle_2, Converter_circle_2> Circle_2;
typedef CGAL::MultiRep<typename K1::Iso_rectangle_2,typename K2::Iso_rectangle_2, Converter_iso_rectangle_2> Iso_rectangle_2;
typedef CGAL::MultiRep<typename K1::Point_3,typename K2::Point_3, Converter_point_3> Point_3;
typedef CGAL::MultiRep<typename K1::Vector_3,typename K2::Vector_3, Converter_vector_3> Vector_3;
typedef CGAL::MultiRep<typename K1::Direction_3,typename K2::Direction_3, Converter_direction_3> Direction_3;
typedef CGAL::MultiRep<typename K1::Line_3,typename K2::Line_3, Converter_line_3> Line_3;
typedef CGAL::MultiRep<typename K1::Plane_3,typename K2::Plane_3, Converter_plane_3> Plane_3;
typedef CGAL::MultiRep<typename K1::Ray_3,typename K2::Ray_3, Converter_ray_3> Ray_3;
typedef CGAL::MultiRep<typename K1::Segment_3,typename K2::Segment_3, Converter_segment_3> Segment_3;
typedef CGAL::MultiRep<typename K1::Triangle_3,typename K2::Triangle_3, Converter_triangle_3> Triangle_3;
typedef CGAL::MultiRep<typename K1::Tetrahedron_3,typename K2::Tetrahedron_3, Converter_tetrahedron_3> Tetrahedron_3;
typedef CGAL::MultiRep<typename K1::Sphere_3,typename K2::Sphere_3, Converter_sphere_3> Sphere_3;
typedef CGAL::MultiRep<typename K1::Iso_cuboid_3,typename K2::Iso_cuboid_3, Converter_iso_cuboid_3> Iso_cuboid_3;
// typedef std::pair<K1::Point_2, K2::Point_2> Point_2;
// ... Same thing for all objects.
#define CGAL_check_pred(X, Y) \
typedef Predicate_checker<typename K1::X, typename K2::X> X; \
X Y() const { return X(K1::Y(), k2.Y()); }
#define CGAL_special_cons(X, Y) \
typedef Special_construction<typename K1::X, typename K2::X, Conv> X; \
X Y() const { return X(K1::Y(), k2.Y()); }
#define CGAL_Kernel_pred(Y,Z) CGAL_check_pred(Y, Z)
#define CGAL_Kernel_cons(Y,Z) CGAL_special_cons(Y,Z)
public:
#include <CGAL/Kernel/interface_macros.h>
};
CGAL_END_NAMESPACE
#endif // CGAL_KERNEL_CHECKER_H
Reference in New Issue View Git Blame Copy Permalink