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

Remove the Kernel Concept Archetypes.

This commit is contained in:
Sylvain Pion 2008-04-11 19:26:21 +00:00
parent f59aab14b7
commit ef71559164
20 changed files with 5 additions and 5815 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Convex_hull_2/test/Convex_hull_2/CMakeLists.txt
View File

@ -18,6 +18,5 @@ if ( CGAL_FOUND )
create_single_source_cgal_program( ch_test_SC.cpp ) create_single_source_cgal_program( ch_test_SC.cpp )
create_single_source_cgal_program( ch_test_SH.cpp ) create_single_source_cgal_program( ch_test_SH.cpp )
create_single_source_cgal_program( ch_test_SS.cpp ) create_single_source_cgal_program( ch_test_SS.cpp )
create_single_source_cgal_program( ka_test_convex_hull_2.cpp )
endif() endif()

69
Convex_hull_2/test/Convex_hull_2/ka_test_convex_hull_2.cpp
View File

@ -1,69 +0,0 @@
// ============================================================================
//
// Copyright (c) 2003 The CGAL Consortium
//
//
//
//
//
// ----------------------------------------------------------------------------
// release :
// release_date :
//
// file : ka_test_convex_hull_2.C
// revision : $Id$
// revision_date : $Date$
// author(s) : Matthias Baesken
//
// coordinator : MPI, Saarbruecken
// ============================================================================
/*
test the different convex_hull algorithm implementations
with the kernel archetype ...
*/
#include <CGAL/basic.h>
#include <CGAL/convex_hull_2.h>
#include <CGAL/ch_akl_toussaint.h>
#include <CGAL/ch_bykat.h>
#include <CGAL/ch_eddy.h>
#include <CGAL/ch_graham_andrew.h>
#include <CGAL/ch_jarvis.h>
#include <CGAL/ch_melkman.h>
#include <CGAL/Kernel_archetype.h>
#include <vector>
#include <list>
typedef CGAL::Kernel_archetype K;
typedef K::Point_2 Point_2;
int main()
{
std::vector<Point_2> input;
Point_2 act;
input.push_back(act);
std::list<Point_2> output;
K traits;
CGAL::convex_hull_2(input.begin(), input.end(), std::back_inserter(output), traits);
CGAL::ch_akl_toussaint(input.begin(), input.end(), std::back_inserter(output), traits);
CGAL::ch_bykat(input.begin(), input.end(), std::back_inserter(output), traits);
CGAL::ch_eddy(input.begin(), input.end(), std::back_inserter(output), traits);
CGAL::ch_graham_andrew(input.begin(), input.end(), std::back_inserter(output), traits);
CGAL::ch_jarvis(input.begin(), input.end(), std::back_inserter(output), traits);
CGAL::ch_melkman(input.begin(), input.end(), std::back_inserter(output), traits);
return 0;
}

4
Installation/CHANGES
View File

@ -13,6 +13,10 @@ Additional supported platforms:
CMake now replaces install_cgal... CMake now replaces install_cgal...
3 Kernels
The Kernel archetypes provided by the 2D/3D linear kernel have been removed.
----------------------------- Release 3.3.1 ---------------------------------- ----------------------------- Release 3.3.1 ----------------------------------
The following corrections have been made: The following corrections have been made:

170
Kernel_23/doc_tex/Kernel_23/kernel_tools.tex
View File

@ -1,170 +0,0 @@
\section{Kernel Related Tools}
\subsection{Introduction}
The following manual sections describe various tools that might be useful for
various kinds of users of the \cgal\ kernel. The kernel concept archetype
describes a minimal model for the \cgal\ kernel that can be used for testing \cgal\
kernel compatibility of geometrical algorithm implementations. It can be useful
for all people developing \cgal-style code that uses the \cgal\ kernel.
%say later something about Kernel checker
%say later something about Filter stuff
%what else (converters ?)
\subsection{Kernel Concept Archetype}
\subsubsection{Introduction}
\cgal\ defines the concept of a geometry kernel. Such a kernel provides types,
construction objects and generalized predicates. Most implementations of CG
algorithms and data structures in the basic library of \cgal\ were done in a way
that classes or functions can be parametrized with a geometric traits class.
In most cases this geometric traits class must be a model of the \cgal\ geometry
kernel concept (but there are some exceptions).
The \cgal\ distribution comes with a number of models (or geometry kernels), for
instance the \ccHtmlNoLinksFrom{Cartesian} kernel (\ccc{CGAL::Cartesian}) or the homogeneous kernel
(\ccc{CGAL::Homogeneous}), that can be used with the packages of the basic
library.
But does it mean that packages of the basic library are fully compatible with
the \cgal\ kernel concept if they can be used with these \cgal\ kernel models? Not
necessarily, because such a package might also use member functions or global
functions/operators, that are implemented for \cgal\ kernel types but not for
other classes or kernels.
That's why it is important to verify whether the documented requirements of a
package are really covered by the implementation. Manual verification is error
prone, so there should be something better available in a generic library for
this application.
That's why the \cgal\ kernel concept archetype \ccc{CGAL::Kernel_archetype} was
developed. It provides all functionality required by the \cgal\ kernel concept,
but nothing more, so it can be seen as a minimal implementation of a model for
the \cgal\ kernel concept. It can be used for testing successful compilation of
packages of the basic library with a minimal model. Deprecated kernel
functionality is not supported. All geometrical types (like the 2d/3d point or
segment types) of \ccc{CGAL::Kernel_archetype} have copy constructors, default
constructors and an assignment operator, and nothing else. Comparison
operators are by default not supported, but can be switched on by the flag \ccc{
CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS}.
The geometrical types of the concept archetype encapsulate no data members, so
run-time checks with the archetype are not very useful
(\ccc{CGAL::Kernel_archetype} is only meant for compilation checks with a
minimal model in the test-suites of \cgal\ packages).
The header file for the concept archetype is \ccc{CGAL/Kernel_archetype.h}.
The package supports the two- and three-dimensional part of the \cgal\ kernel
concept. The d-dimensional part is not supported.
\subsubsection{Restricting the Interface}
Normally packages of the Basic Library or Extension packages use only a small
subset of the functionality offered by models of the \cgal\ kernel concept. In
these cases testing with a model that offers only this (used and) documented
subset makes sense. \ccc{CGAL::Kernel_archetype} normally offers the full
functionality (all types, functors and constructions of a \cgal\ kernel model),
but it is possible to restrict the interface.\\ If you want to do this, you
have to define the macro \ccc{CGAL_CA_LIMITED_INTERFACE} (before the
inclusion of \ccc{CGAL/Kernel_archetype.h}) for switching on the interface
limitation. Now you have to tell the kernel archetype what types have to be
provided by it. For every type you have to define a macro. The name of the
macro is \ccc{CGAL_CA_NAME_OF_KERNEL_TYPE}, where \ccc{
NAME_OF_KERNEL_TYPE} is the name of the kernel type (written in capitals)
that has to be provided by the kernel archetype for a specific package. Lets
have a look at a small example. The kernel archetype has to provide in some
test suite a limited interface. The interface has to offer type definitions
for \ccc{Point_3} and \ccc{Plane_3} and the 3d \ccHtmlNoLinksFrom{orientation} functor type
definition \ccc{Orientation_3}:
\ccHtmlLinksOff
\begin{ccExampleCode}
// limit interface of the Kernel_archetype
#define CGAL_CA_LIMITED_INTERFACE
#define CGAL_CA_POINT_3
#define CGAL_CA_PLANE_3
#define CGAL_CA_ORIENTATION_3
#include <CGAL/Kernel_archetype.h>
\end{ccExampleCode}
\ccHtmlLinksOn
Now other kernel functionality is removed from the interface of
\ccc{CGAL::Kernel_archetype}, so access to these other kernel types will result
in a compile-time error.
Another option is to use an own archetype class that encapsulates only the
needed type definitions and the corresponding member functions.
See the following code snippet for a simple example.
\ccHtmlLinksOff
\begin{ccExampleCode}
#include <CGAL/Kernel_archetype.h>
// build an own archetype class ...
// get needed types from the kernel archetype ...
typedef CGAL::Kernel_archetype KA;
typedef KA::Point_3 KA_Point_3;
typedef KA::Plane_3 KA_Plane_3;
typedef KA::Construct_opposite_plane_3 KA_Construct_opposite_plane_3;
// reuse the types from the kernel archetype in the own archetype class
struct My_archetype {
typedef KA_Point_3 Point_3;
typedef KA_Plane_3 Plane_3;
typedef KA_Construct_opposite_plane_3 Construct_opposite_plane_3;
Construct_opposite_plane_3
construct_opposite_plane_3_object()
{ return Construct_opposite_plane_3(); }
};
\end{ccExampleCode}
\ccHtmlLinksOn
\subsubsection{Example Program}
The following example shows a program for checking the 2d convex hull algorithm
of CGAL with the archetype. You can see the usage of the
\ccc{CGAL::Kernel_archetype} that replaces a \cgal\ kernel that is normally used.
\ccHtmlLinksOff
{\bf test\_convex\_hull\_2.cpp :}
\begin{ccExampleCode}
#include <CGAL/basic.h>
#include <CGAL/convex_hull_2.h>
#include <CGAL/Kernel_archetype.h>
#include <list>
typedef CGAL::Kernel_archetype K;
typedef K::Point_2 Point_2;
int main()
{
std::list<Point_2> input;
Point_2 act;
input.push_back(act);
std::list<Point_2> output;
K traits;
CGAL::convex_hull_2(input.begin(), input.end(),
std::back_inserter(output), traits);
return 0;
}
\end{ccExampleCode}
\ccHtmlLinksOn

1
Kernel_23/doc_tex/Kernel_23/main.tex
View File

@ -13,5 +13,4 @@
\input{Kernel_23/kernel_geometry} \input{Kernel_23/kernel_geometry}
\input{Kernel_23/predicates_constructions} \input{Kernel_23/predicates_constructions}
\input{Kernel_23/extensible_kernel} \input{Kernel_23/extensible_kernel}
\input{Kernel_23/kernel_tools}

67
Kernel_23/doc_tex/Kernel_23_ref/Kernel_archetype.tex
View File

@ -1,67 +0,0 @@
\begin{ccRefClass}{Kernel_archetype}
%\KernelRefLayout\gdef\ccTagOperatorLayout{\ccFalse}
\ccDefinition
\ccc{CGAL::Kernel_archetype} is a concept archetype (minimal model) for the CGAL kernel concept.
It provides all functionality required by the CGAL kernel concept, but nothing more.
It can be used for testing successful compilation of packages of the basic library with a minimal
model. Deprecated kernel functionality is not supported. All geometrical types (like the 2d/3d point or segment types)
of \ccc{CGAL::Kernel_archetype} have
copy constructors, default constructors and an assignment operator, and nothing else.
Comparison operators are by default not supported, but can be switched on by defining the macro
\ccc{CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS}.
The geometrical types of the concept archetype encapsulate no data members, so run-time checks with the archetype
are not very useful (\ccc{CGAL::Kernel_archetype} is only meant for compilation checks with a minimal model in the test-suites
of CGAL packages).
The package supports the two- and three-dimensional part of the CGAL kernel concept. The d-dimensional
part is not supported.
\ccc{CGAL::Kernel_archetype} normally offers the full functionality (all types, functors and constructions
of a CGAL kernel model), but it is possible to restrict the interface. This can be useful
for testing packages that require only a very small subset of the functionality offered
by CGAL kernel models.
If you want to do this, you have to define the macro \ccc{CGAL_CA_LIMITED_INTERFACE}
(before the inclusion of {\em CGAL/Kernel\_archetype.h}) to switch on the interface limitation.
Now you have to tell the kernel archetype the types it has to provide for the specific package.
For every type you have to define a macro.
The name of the macro is \ccc{CGAL_CA_NAME_OF_KERNEL_TYPE}, where \ccc{NAME_OF_KERNEL_TYPE} is the name
of the kernel type (written in capitals) that has to be provided by the kernel archetype for a specific package.
If, for example, a package only needs type definitions for \ccc{Point_2} and \ccc{Orientation_2}, you would
define \ccc{CGAL_CA_LIMITED_INTERFACE}, \ccc{CGAL_CA_POINT_2} and \ccc{CGAL_CA_ORIENTATION_2} .
\ccIsModel
\ccRefConceptPage{Kernel}
\ccInclude{CGAL/Kernel_archetype.h}
\ccCreation
\ccCreationVariable{ka}
\ccConstructor{Kernel_archetype();}{Default constructor.}
\ccTypes
We provide all type definitions that must be provided by a CGAL kernel model.
See the CGAL kernel concept manual pages for details.
Deprecated functionality is not supported. You can restrict the interface
by defining macros (see the definition for details).
\ccOperations
For each of the function objects of the kernel archetype, there is a member function
that requires no arguments and returns an instance of that function object.
The name of the member function is the uncapitalized name of the type
returned with the suffix \ccc{_object} appended.
\ccSeeAlso
\ccRefIdfierPage{CGAL::Cartesian<FieldNumberType>} \\
\ccRefIdfierPage{CGAL::Homogeneous<RingNumberType>} \\
\ccRefIdfierPage{CGAL::Simple_cartesian<FieldNumberType>} \\
\end{ccRefClass}

1
Kernel_23/doc_tex/Kernel_23_ref/main.tex
View File

@ -40,7 +40,6 @@ in the kernel.
\input{Kernel_23_ref/Homogeneous_converter.tex} \input{Kernel_23_ref/Homogeneous_converter.tex}
\input{Kernel_23_ref/homogeneous_to_cartesian.tex} \input{Kernel_23_ref/homogeneous_to_cartesian.tex}
\input{Kernel_23_ref/homogeneous_to_quotient_cartesian.tex} \input{Kernel_23_ref/homogeneous_to_quotient_cartesian.tex}
\input{Kernel_23_ref/Kernel_archetype.tex}
\input{Kernel_23_ref/Kernel_traits.tex} \input{Kernel_23_ref/Kernel_traits.tex}
\input{Kernel_23_ref/Simple_cartesian.tex} \input{Kernel_23_ref/Simple_cartesian.tex}
\input{Kernel_23_ref/Simple_homogeneous.tex} \input{Kernel_23_ref/Simple_homogeneous.tex}

3
Kernel_23/examples/Kernel_23/CMakeLists.txt
View File

@ -13,8 +13,5 @@ if ( CGAL_FOUND )
include(CreateSingleSourceCGALProgram) include(CreateSingleSourceCGALProgram)
create_single_source_cgal_program( MyKernel.cpp ) create_single_source_cgal_program( MyKernel.cpp )
create_single_source_cgal_program( test_delaunay_2.cpp )
create_single_source_cgal_program( test_polyhedron_prog_incr_builder.cpp )
create_single_source_cgal_program( test_polyhedron_prog_incr_builder_own_archetype.cpp )
endif() endif()

12
Kernel_23/examples/Kernel_23/makefile
View File

@ -27,8 +27,6 @@ LDFLAGS = \
#---------------------------------------------------------------------# #---------------------------------------------------------------------#
all: \ all: \
test_delaunay_2 \
test_polyhedron_prog_incr_builder \
MyKernel MyKernel
@ -36,16 +34,8 @@ MyKernel
MyKernel$(EXE_EXT): MyKernel$(OBJ_EXT) MyKernel$(EXE_EXT): MyKernel$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)MyKernel MyKernel$(OBJ_EXT) $(LDFLAGS) $(CGAL_CXX) $(LIBPATH) $(EXE_OPT)MyKernel MyKernel$(OBJ_EXT) $(LDFLAGS)
test_delaunay_2$(EXE_EXT): test_delaunay_2$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)test_delaunay_2 test_delaunay_2$(OBJ_EXT) $(LDFLAGS)
test_polyhedron_prog_incr_builder$(EXE_EXT): test_polyhedron_prog_incr_builder$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)test_polyhedron_prog_incr_builder test_polyhedron_prog_incr_builder$(OBJ_EXT) $(LDFLAGS)
clean: \ clean: \
MyKernel.clean \ MyKernel.clean
test_delaunay_2.clean \
test_polyhedron_prog_incr_builder.clean
#---------------------------------------------------------------------# #---------------------------------------------------------------------#
# suffix rules # suffix rules

24
Kernel_23/examples/Kernel_23/test_delaunay_2.cpp
View File

@ -1,24 +0,0 @@
// small example for compilation
// check of Delaunay_triangulation_2 using the kernel concept
// archetype
#include <CGAL/basic.h>
#include <CGAL/Triangulation_2.h>
#include <CGAL/Delaunay_triangulation_2.h>
#include <CGAL/Kernel_archetype.h>
typedef CGAL::Kernel_archetype K;
typedef K::Point_2 Point;
typedef CGAL::Delaunay_triangulation_2<K> Delaunay_triang_2;
Delaunay_triang_2 dt;
int main()
{
std::list<Point> input;
Point act;
dt.insert(act);
return 0;
}

50
Kernel_23/examples/Kernel_23/test_polyhedron_prog_incr_builder.cpp
View File

@ -1,50 +0,0 @@
// original version see examples/Polyhedron/polyhedron_prog_incr_builder.cpp
// this time we test compilation with the
// kernel concept archetype
// we use interface restrictions in this example
#include <CGAL/basic.h>
#include <CGAL/Polyhedron_incremental_builder_3.h>
#include <CGAL/Polyhedron_3.h>
// limit interface of the kernel archetype ...
#define CGAL_CA_LIMITED_INTERFACE
#define CGAL_CA_POINT_3
#define CGAL_CA_PLANE_3
#include <CGAL/Kernel_archetype.h>
// A modifier creating a triangle with the incremental builder.
template <class HDS>
class Build_triangle : public CGAL::Modifier_base<HDS> {
public:
Build_triangle() {}
void operator()( HDS& hds) {
// Postcondition: `hds' is a valid polyhedral surface.
CGAL::Polyhedron_incremental_builder_3<HDS> B( hds, true);
B.begin_surface( 3, 1, 6);
typedef typename HDS::Vertex Vertex;
typedef typename Vertex::Point Point;
B.add_vertex( Point());
B.add_vertex( Point());
B.add_vertex( Point());
B.begin_facet();
B.add_vertex_to_facet( 0);
B.add_vertex_to_facet( 1);
B.add_vertex_to_facet( 2);
B.end_facet();
B.end_surface();
}
};
typedef CGAL::Kernel_archetype Kernel;
typedef CGAL::Polyhedron_3<Kernel> Polyhedron;
typedef Polyhedron::HalfedgeDS HalfedgeDS;
int main() {
Polyhedron P;
Build_triangle<HalfedgeDS> triangle;
P.delegate( triangle);
CGAL_assertion( P.is_triangle( P.halfedges_begin()));
return 0;
}

65
Kernel_23/examples/Kernel_23/test_polyhedron_prog_incr_builder_own_archetype.cpp
View File

@ -1,65 +0,0 @@
// original version see examples/Polyhedron/polyhedron_prog_incr_builder.cpp
// this time we test compilation with
// an own archetype that uses functionality
// provided by the kernel archetype
#include <CGAL/basic.h>
#include <CGAL/Polyhedron_incremental_builder_3.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/Kernel_archetype.h>
// build an own archetype class ...
// provide 3d point and plane types ...
// get some types from the kernel archetype ...
typedef CGAL::Kernel_archetype KA;
typedef KA::Point_3 KA_Point_3;
typedef KA::Plane_3 KA_Plane_3;
typedef KA::Construct_opposite_plane_3 KA_Construct_opposite_plane_3;
struct My_archetype {
typedef KA_Point_3 Point_3;
typedef KA_Plane_3 Plane_3;
typedef KA_Construct_opposite_plane_3 Construct_opposite_plane_3;
Construct_opposite_plane_3
construct_opposite_plane_3_object()
{ return Construct_opposite_plane_3(); }
};
// A modifier creating a triangle with the incremental builder.
template <class HDS>
class Build_triangle : public CGAL::Modifier_base<HDS> {
public:
Build_triangle() {}
void operator()( HDS& hds) {
// Postcondition: `hds' is a valid polyhedral surface.
CGAL::Polyhedron_incremental_builder_3<HDS> B( hds, true);
B.begin_surface( 3, 1, 6);
typedef typename HDS::Vertex Vertex;
typedef typename Vertex::Point Point;
B.add_vertex( Point());
B.add_vertex( Point());
B.add_vertex( Point());
B.begin_facet();
B.add_vertex_to_facet( 0);
B.add_vertex_to_facet( 1);
B.add_vertex_to_facet( 2);
B.end_facet();
B.end_surface();
}
};
typedef My_archetype Kernel;
typedef CGAL::Polyhedron_3<Kernel> Polyhedron;
typedef Polyhedron::HalfedgeDS HalfedgeDS;
int main() {
Polyhedron P;
Build_triangle<HalfedgeDS> triangle;
P.delegate( triangle);
CGAL_assertion( P.is_triangle( P.halfedges_begin()));
return 0;
}

3475
Kernel_23/include/CGAL/Kernel/concept_archetype_functors.h
View File

File diff suppressed because it is too large Load Diff

1086
Kernel_23/include/CGAL/Kernel/concept_archetype_interface_macros.h
View File

File diff suppressed because it is too large Load Diff

168
Kernel_23/include/CGAL/Kernel_archetype.h
View File

@ -1,168 +0,0 @@
// Copyright (c) 1999,2003 Utrecht University (The Netherlands),
// ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
// (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
// and Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
//
// Author(s) : Matthias Baesken
#ifndef CGAL_KERNEL_ARCHETYPE
#define CGAL_KERNEL_ARCHETYPE
#include <CGAL/basic.h>
#include <CGAL/Object.h>
#include <CGAL/functional_base.h>
#include <CGAL/Quotient.h>
#include <CGAL/concept_archetype_2.h>
#include <CGAL/concept_archetype_3.h>
#include <CGAL/Kernel/concept_archetype_functors.h>
CGAL_BEGIN_NAMESPACE
class Kernel_archetype {
public:
// 2d
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_FT)
typedef double FT;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_RT)
typedef double RT;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_POINT_2)
typedef Point_2_archetype Point_2;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_VECTOR_2)
typedef Vector_2_archetype Vector_2;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_DIRECTION_2)
typedef Direction_2_archetype Direction_2;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LINE_2)
typedef Line_2_archetype Line_2;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_RAY_2)
typedef Ray_2_archetype Ray_2;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_SEGMENT_2)
typedef Segment_2_archetype Segment_2;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_TRIANGLE_2)
typedef Triangle_2_archetype Triangle_2;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ISO_RECTANGLE_2)
typedef Iso_rectangle_2_archetype Iso_rectangle_2;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CIRCLE_2)
typedef Circle_2_archetype Circle_2;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_OBJECT_2)
typedef CGAL::Object Object_2;
#endif
// 3d
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_POINT_3)
typedef Point_3_archetype Point_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_VECTOR_3)
typedef Vector_3_archetype Vector_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_DIRECTION_3)
typedef Direction_3_archetype Direction_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ISO_CUBOID_3)
typedef Iso_cuboid_3_archetype Iso_cuboid_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LINE_3)
typedef Line_3_archetype Line_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_RAY_3)
typedef Ray_3_archetype Ray_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_SEGMENT_3)
typedef Segment_3_archetype Segment_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_SPHERE_3)
typedef Sphere_3_archetype Sphere_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_PLANE_3)
typedef Plane_3_archetype Plane_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_TRIANGLE_3)
typedef Triangle_3_archetype Triangle_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_TETRAHEDRON_3)
typedef Tetrahedron_3_archetype Tetrahedron_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_OBJECT_3)
typedef CGAL::Object Object_3;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || \
defined(CGAL_CA_CARTESIAN_COORDINATE_CONST_ITERATOR_2)
typedef Cartesian_coordinate_const_iterator_2_archetype
Cartesian_const_iterator_2;
#endif
#if !defined(CGAL_CA_LIMITED_INTERFACE) || \
defined(CGAL_CA_CARTESIAN_COORDINATE_CONST_ITERATOR_3)
typedef Cartesian_coordinate_const_iterator_3_archetype
Cartesian_const_iterator_3;
#endif
// functors and access functions ...
// predicate ...
#define CGAL_Kernel_pred(Y,Z) typedef CGALca::Y<Kernel_archetype> Y; \
Y Z() const {return Y();}
// accessor function ...
#define CGAL_Kernel_cons(Y,Z) CGAL_Kernel_pred(Y,Z)
#include <CGAL/Kernel/concept_archetype_interface_macros.h>
};
CGAL_END_NAMESPACE
#endif

244
Kernel_23/include/CGAL/concept_archetype_2.h
View File

@ -1,244 +0,0 @@
// Copyright (c) 1999,2003 Utrecht University (The Netherlands),
// ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
// (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
// and Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
//
// Author(s) : Matthias Baesken
#ifndef CGAL_CONCEPT_ARCHETYPE_2
#define CGAL_CONCEPT_ARCHETYPE_2
// 2d CA types (and number types)...
#define CGAL_concept_archetype_constructors(T) \
template<class T1> T(const T1&) { } \
template<class T1,class T2> T(const T1&,const T2&) { } \
template<class T1,class T2,class T3> T(const T1&,const T2&,const T3&) { } \
template<class T1,class T2,class T3,class T4> \
T(const T1&,const T2&,const T3&,const T4&) { } \
template<class T1,class T2,class T3,class T4,class T5> \
T(const T1&,const T2&,const T3&,const T4&,const T5&) { }
CGAL_BEGIN_NAMESPACE
struct Point_2_archetype {
Point_2_archetype() { }
Point_2_archetype(const Point_2_archetype&) { }
Point_2_archetype& operator=(const Point_2_archetype&) { return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Point_2_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Point_2_archetype& obj1,
const Point_2_archetype& obj2)
{ return true; }
inline bool operator!=(const Point_2_archetype& obj1,
const Point_2_archetype& obj2)
{ return true; }
#endif
struct Segment_2_archetype {
Segment_2_archetype() { }
Segment_2_archetype(const Segment_2_archetype&) { }
Segment_2_archetype& operator=(const Segment_2_archetype&) { return *this;}
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Segment_2_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool
operator==(const Segment_2_archetype& obj1, const Segment_2_archetype& obj2)
{ return true; }
inline bool
operator!=(const Segment_2_archetype& obj1, const Segment_2_archetype& obj2)
{ return true; }
#endif
struct Line_2_archetype {
Line_2_archetype() { }
Line_2_archetype(const Line_2_archetype&) { }
Line_2_archetype& operator=(const Line_2_archetype&) { return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Line_2_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool
operator==(const Line_2_archetype& obj1, const Line_2_archetype& obj2)
{ return true; }
inline bool
operator!=(const Line_2_archetype& obj1, const Line_2_archetype& obj2)
{ return true; }
#endif
struct Ray_2_archetype {
Ray_2_archetype() { }
Ray_2_archetype(const Ray_2_archetype&) { }
Ray_2_archetype& operator=(const Ray_2_archetype&) { return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Ray_2_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool
operator==(const Ray_2_archetype& obj1, const Ray_2_archetype& obj2)
{ return true; }
inline bool
operator!=(const Ray_2_archetype& obj1, const Ray_2_archetype& obj2)
{ return true; }
#endif
struct Vector_2_archetype {
Vector_2_archetype() { }
Vector_2_archetype(const Vector_2_archetype&) { }
Vector_2_archetype& operator=(const Vector_2_archetype&) { return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Vector_2_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool
operator==(const Vector_2_archetype& obj1, const Vector_2_archetype& obj2)
{ return true; }
inline bool
operator!=(const Vector_2_archetype& obj1, const Vector_2_archetype& obj2)
{ return true; }
#endif
struct Direction_2_archetype {
Direction_2_archetype() { }
Direction_2_archetype(const Direction_2_archetype&) { }
Direction_2_archetype& operator=(const Direction_2_archetype&)
{ return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Direction_2_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Direction_2_archetype& obj1,
const Direction_2_archetype& obj2)
{ return true; }
inline bool operator!=(const Direction_2_archetype& obj1,
const Direction_2_archetype& obj2)
{ return true; }
#endif
struct Triangle_2_archetype {
Triangle_2_archetype() { }
Triangle_2_archetype(const Triangle_2_archetype&) { }
Triangle_2_archetype& operator=(const Triangle_2_archetype&)
{ return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Triangle_2_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Triangle_2_archetype& obj1,
const Triangle_2_archetype& obj2)
{ return true; }
inline bool operator!=(const Triangle_2_archetype& obj1,
const Triangle_2_archetype& obj2)
{ return true; }
#endif
struct Circle_2_archetype {
Circle_2_archetype() { }
Circle_2_archetype(const Circle_2_archetype&) { }
Circle_2_archetype& operator=(const Circle_2_archetype&) { return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Circle_2_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool
operator==(const Circle_2_archetype& obj1, const Circle_2_archetype& obj2)
{ return true; }
inline bool
operator!=(const Circle_2_archetype& obj1, const Circle_2_archetype& obj2)
{ return true; }
#endif
struct Iso_rectangle_2_archetype {
Iso_rectangle_2_archetype() { }
Iso_rectangle_2_archetype(const Iso_rectangle_2_archetype&) { }
Iso_rectangle_2_archetype& operator=(const Iso_rectangle_2_archetype&)
{ return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Iso_rectangle_2_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Iso_rectangle_2_archetype& obj1,
const Iso_rectangle_2_archetype& obj2)
{ return true; }
inline bool operator!=(const Iso_rectangle_2_archetype& obj1,
const Iso_rectangle_2_archetype& obj2)
{ return true; }
#endif
struct Cartesian_coordinate_const_iterator_2_archetype {
Cartesian_coordinate_const_iterator_2_archetype() { }
Cartesian_coordinate_const_iterator_2_archetype&
operator=(const Cartesian_coordinate_const_iterator_2_archetype&)
{ return *this; }
};
CGAL_END_NAMESPACE
#undef CGAL_concept_archetype_constructors
#endif

288
Kernel_23/include/CGAL/concept_archetype_3.h
View File

@ -1,288 +0,0 @@
// Copyright (c) 1999,2003 Utrecht University (The Netherlands),
// ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
// (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
// and Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
//
// Author(s) : Matthias Baesken
#ifndef CGAL_CONCEPT_ARCHETYPE_3
#define CGAL_CONCEPT_ARCHETYPE_3
// 3d CA types ...
#define CGAL_concept_archetype_constructors(T) \
template<class T1> T(const T1&) { } \
template<class T1,class T2> T(const T1&,const T2&) { } \
template<class T1,class T2,class T3> T(const T1&,const T2&,const T3&) { } \
template<class T1,class T2,class T3,class T4> \
T(const T1&,const T2&,const T3&,const T4&) { } \
template<class T1,class T2,class T3,class T4,class T5> \
T(const T1&,const T2&,const T3&,const T4&,const T5&) { }
CGAL_BEGIN_NAMESPACE
struct Point_3_archetype {
Point_3_archetype() { }
Point_3_archetype(const Point_3_archetype&) { }
Point_3_archetype& operator=(const Point_3_archetype&) { return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Point_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Point_3_archetype& obj1,
const Point_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Point_3_archetype& obj1,
const Point_3_archetype& obj2)
{ return true; }
#endif
struct Segment_3_archetype {
Segment_3_archetype() { }
Segment_3_archetype(const Segment_3_archetype&) { }
Segment_3_archetype& operator=(const Segment_3_archetype&){return *this;}
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Segment_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Segment_3_archetype& obj1,
const Segment_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Segment_3_archetype& obj1,
const Segment_3_archetype& obj2)
{ return true; }
#endif
struct Line_3_archetype {
Line_3_archetype() { }
Line_3_archetype(const Line_3_archetype&) { }
Line_3_archetype& operator=(const Line_3_archetype&){return *this;}
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Line_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Line_3_archetype& obj1,
const Line_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Line_3_archetype& obj1,
const Line_3_archetype& obj2)
{ return true; }
#endif
struct Ray_3_archetype {
Ray_3_archetype() { }
Ray_3_archetype(const Ray_3_archetype&) { }
Ray_3_archetype& operator=(const Ray_3_archetype&) { return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Ray_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Ray_3_archetype& obj1,
const Ray_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Ray_3_archetype& obj1,
const Ray_3_archetype& obj2)
{ return true; }
#endif
struct Vector_3_archetype {
Vector_3_archetype() { }
Vector_3_archetype(const Vector_3_archetype&) { }
Vector_3_archetype& operator=(const Vector_3_archetype&) { return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Vector_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Vector_3_archetype& obj1,
const Vector_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Vector_3_archetype& obj1,
const Vector_3_archetype& obj2)
{ return true; }
#endif
struct Direction_3_archetype {
Direction_3_archetype() { }
Direction_3_archetype(const Direction_3_archetype&) { }
Direction_3_archetype& operator=(const Direction_3_archetype&)
{ return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Direction_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Direction_3_archetype& obj1,
const Direction_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Direction_3_archetype& obj1,
const Direction_3_archetype& obj2)
{ return true; }
#endif
struct Plane_3_archetype {
Plane_3_archetype() { }
Plane_3_archetype(const Plane_3_archetype&) { }
Plane_3_archetype& operator=(const Plane_3_archetype&) { return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Plane_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Plane_3_archetype& obj1,
const Plane_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Plane_3_archetype& obj1,
const Plane_3_archetype& obj2)
{ return true; }
#endif
struct Iso_cuboid_3_archetype {
Iso_cuboid_3_archetype() { }
Iso_cuboid_3_archetype(const Iso_cuboid_3_archetype&) { }
Iso_cuboid_3_archetype& operator=(const Iso_cuboid_3_archetype&)
{ return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Iso_cuboid_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Iso_cuboid_3_archetype& obj1,
const Iso_cuboid_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Iso_cuboid_3_archetype& obj1,
const Iso_cuboid_3_archetype& obj2)
{ return true; }
#endif
struct Sphere_3_archetype {
Sphere_3_archetype() { }
Sphere_3_archetype(const Sphere_3_archetype&) { }
Sphere_3_archetype& operator=(const Sphere_3_archetype&)
{ return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Sphere_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Sphere_3_archetype& obj1,
const Sphere_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Sphere_3_archetype& obj1,
const Sphere_3_archetype& obj2)
{ return true; }
#endif
struct Triangle_3_archetype {
Triangle_3_archetype() { }
Triangle_3_archetype(const Triangle_3_archetype&) { }
Triangle_3_archetype& operator=(const Triangle_3_archetype&)
{ return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Triangle_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Triangle_3_archetype& obj1,
const Triangle_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Triangle_3_archetype& obj1,
const Triangle_3_archetype& obj2)
{ return true; }
#endif
struct Tetrahedron_3_archetype {
Tetrahedron_3_archetype() { }
Tetrahedron_3_archetype(const Tetrahedron_3_archetype&) { }
Tetrahedron_3_archetype& operator=(const Tetrahedron_3_archetype&)
{ return *this; }
#if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS)
CGAL_concept_archetype_constructors(Tetrahedron_3_archetype)
#endif
};
#if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS)
inline bool operator==(const Tetrahedron_3_archetype& obj1,
const Tetrahedron_3_archetype& obj2)
{ return true; }
inline bool operator!=(const Tetrahedron_3_archetype& obj1,
const Tetrahedron_3_archetype& obj2)
{ return true; }
#endif
struct Cartesian_coordinate_const_iterator_3_archetype {
Cartesian_coordinate_const_iterator_3_archetype() { }
Cartesian_coordinate_const_iterator_3_archetype&
operator=(const Cartesian_coordinate_const_iterator_3_archetype&)
{ return *this; }
};
CGAL_END_NAMESPACE
#undef CGAL_concept_archetype_constructors
#endif

2
Kernel_23/test/Kernel_23/CMakeLists.txt
View File

@ -23,8 +23,6 @@ if ( CGAL_FOUND )
create_single_source_cgal_program( Lazy_kernel.cpp ) create_single_source_cgal_program( Lazy_kernel.cpp )
create_single_source_cgal_program( Simple_cartesian.cpp ) create_single_source_cgal_program( Simple_cartesian.cpp )
create_single_source_cgal_program( Simple_homogeneous.cpp ) create_single_source_cgal_program( Simple_homogeneous.cpp )
create_single_source_cgal_program( test_kernel_archetype_2.cpp )
create_single_source_cgal_program( test_kernel_archetype_3.cpp )
create_single_source_cgal_program( test_kernel__.cpp ) create_single_source_cgal_program( test_kernel__.cpp )
endif() endif()

45
Kernel_23/test/Kernel_23/test_kernel_archetype_2.cpp
View File

@ -1,45 +0,0 @@
// Copyright (c) 1999,2003 Utrecht University (The Netherlands),
// ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
// (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
// and Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with CGAL.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
//
// Author(s) : Matthias Baesken
#include <CGAL/basic.h>
#include <CGAL/Cartesian.h>
#ifndef CGAL_NO_DEPRECATED_CODE
# define CGAL_NO_DEPRECATED_CODE
#endif
#define CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS
#include <CGAL/Kernel_archetype.h>
// needed in kernel testsuite ...
CGAL::Vector_2_archetype operator-(const CGAL::Vector_2_archetype& v)
{ return v; }
#include "CGAL/_test_new_2.h"
typedef CGAL::Kernel_archetype Kernel;
int main()
{
test_new_2( Kernel() );
return 0;
}

45
Kernel_23/test/Kernel_23/test_kernel_archetype_3.cpp
View File

@ -1,45 +0,0 @@
// Copyright (c) 1999,2003 Utrecht University (The Netherlands),
// ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
// (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
// and Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with CGAL.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
//
// Author(s) : Matthias Baesken
#include <CGAL/basic.h>
#include <CGAL/Cartesian.h>
#ifndef CGAL_NO_DEPRECATED_CODE
# define CGAL_NO_DEPRECATED_CODE
#endif
#define CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS
#include <CGAL/Kernel_archetype.h>
// needed in kernel testsuite ...
CGAL::Vector_3_archetype operator-(const CGAL::Vector_3_archetype& v)
{ return v; }
#include "CGAL/_test_new_3.h"
typedef CGAL::Kernel_archetype Kernel;
int main()
{
test_new_3( Kernel() );
return 0;
}