mirror of https://github.com/CGAL/cgal
1123 lines
33 KiB
TeX
1123 lines
33 KiB
TeX
% ----------------------------------------------------------------------
|
|
% Test document for the CGAL manual LaTeX style:
|
|
%
|
|
% 16.08.1995 Lutz Kettner
|
|
%
|
|
% $Revision$
|
|
% $Date$
|
|
% ----------------------------------------------------------------------
|
|
% The style is compatible with LaTeX2e:
|
|
\documentclass[12pt]{article}
|
|
\usepackage{latexsym}
|
|
\usepackage{amssymb}
|
|
|
|
% LaTeX:
|
|
% \documentstyle[12pt]{article}
|
|
|
|
%\pagestyle{empty}
|
|
\textwidth 15.4cm
|
|
\textheight 24cm
|
|
\topmargin -14mm
|
|
\evensidemargin 3mm
|
|
\oddsidemargin 3mm
|
|
|
|
\usepackage{cc_manual}
|
|
|
|
\parindent0em
|
|
\setlength{\parskip}{1ex minus 0.9ex}
|
|
|
|
\sloppy
|
|
|
|
% ----------------------------------------------------------------------
|
|
\title {Test Suite for the cc\_manual.sty}
|
|
\author{Lutz Kettner}
|
|
\date{\ccRevision. \ccDate}
|
|
|
|
\begin{document}
|
|
|
|
\maketitle
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Introduction}
|
|
|
|
This document is a test suite for the {\tt cc\_manual.sty}. It is
|
|
arbitrary structured and mostly no introductory explanations will be given.
|
|
Each section will test a particularly feature. Sections were written
|
|
while developing the style or while debugging. Thanks for bug-reports
|
|
made so far and for future reports. Please send bug-reports to {\tt
|
|
kettner@inf.ethz.ch}.
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Structuring Macros}
|
|
|
|
\ccDefinition Here comes the general introductory explanation for a
|
|
class etc. The necessary include files.
|
|
|
|
\ccInclude{CGAL/Vector_2.h}\\
|
|
\ccInclude{CGAL/Point_2.h}
|
|
|
|
\ccAccessFunctions
|
|
|
|
\ccPrecond Specific conditions can be stated as preconditions in any place.
|
|
|
|
\ccCreation Constructors are defined and explained here.
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{ccStyle Character Test}
|
|
|
|
The formatting macros handle for example the special characters \_,
|
|
{\tt <}, {\tt >}, and {\tt \&} as they appear in \CC\ names and the
|
|
characters \#, \%, \ccHat, and \ccTilde\ as they appear with
|
|
operators. See the following example that is printed using the
|
|
\verb+\cc+{\tt Style} macro:
|
|
|
|
\ccStyle{
|
|
#define %^~$@&$ Ret_Type<Template_Param, X<Y> > fct_foo( const X<Y> &a);}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{Demo_Class1}
|
|
\ccSection{A Simple Class}
|
|
|
|
\ccCreationVariable{p}
|
|
|
|
\ccStyle{#include< Demo_Class1.h>}
|
|
\ccTwo{Demo_Class1 p;X}{}
|
|
|
|
\ccConstructor{Demo_Class1();}{introduces
|
|
a variable \ccVar\ initialized to the default. \CC\ code:
|
|
{\tt Demo\_Class1();}. Test ccStyle: \ccStyle{Underscore\_within
|
|
ccStyle}.}
|
|
|
|
\ccConstructor{Demo_Class1( const Demo_Class1 &);}{copy
|
|
constructor. \CC\ code: {\tt Demo\_Class1(const Demo\_Class1 \&);}}
|
|
|
|
\ccThree{Demo_Class1}{p.x();}{}
|
|
|
|
\ccMethod{FT x() const;}{Cartesian x-coordinate. \CC\ code: {\tt
|
|
FT x() const;}}
|
|
|
|
\ccMethod{const FT& y();}{Cartesian y-coordinate. \CC\ code: {\tt
|
|
const FT\& y();}}
|
|
|
|
\ccMethod{Demo_Class1
|
|
transform( const CGAL_HAff_transformation<FT,RT> &t) const;
|
|
}{ Longish declarations forces the comment to start in
|
|
the next line.}
|
|
|
|
\ccMethod{Demo_Class1
|
|
longish_function_name(
|
|
const CGAL_Aff_transformation<FT,RT> &t,
|
|
const Dummy_Type &q,
|
|
Long_Type_Name Variable_Also_Long) const;
|
|
}{ Even more longish declarations forces the parameters printed
|
|
one per line. This was the default formatting.}
|
|
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Spaces Around Pointer * and Reference \& Symbols}
|
|
|
|
Reference or pointer parameters can occur on both sides of the
|
|
separating space between the return type and the function or method
|
|
name. The formatting normalizes them to the left side. This
|
|
formatting is not done within the parameters (, but maybe in the
|
|
future). An example:
|
|
|
|
\ccThree{Demo_Class&&}{p.x();}{}
|
|
|
|
\ccFunction{Demo_Class& foo1( int& a, int* b);}{}
|
|
\ccGlue
|
|
\ccFunction{Demo_Class* foo2( int& a, int* b);}{}
|
|
\ccGlue
|
|
\ccFunction{Demo_Class &foo3( int &a, int *b);}{}
|
|
\ccGlue
|
|
\ccFunction{Demo_Class *foo4( int &a, int *b);}{}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{Demo_Class2}
|
|
\section{Operator Test}
|
|
\ccCreationVariable{p}
|
|
|
|
Type casting through a conversion operator is the default behavior
|
|
for the formatting routine if the return type before the {\tt
|
|
operator} keyword is empty.
|
|
|
|
\ccThree{Demo_Class&&}{A< FT>(p);}{}
|
|
\ccMethod{ operator int () const;}{Conversion operator.}
|
|
\ccGlue
|
|
\ccMethod{operator A<FT>() const;}{Conversion operator.}
|
|
|
|
Sometimes, there is a choice between
|
|
implementing an operator as a method or as a function. Both
|
|
declarations will produce the same formatting, as demonstrated
|
|
with the next two declarations.
|
|
|
|
|
|
\ccFunction{Demo_Class2
|
|
operator+(Demo_Class2 p, Demo_Class2 q);}{Declaration via function.}
|
|
\ccGlue
|
|
\ccMethod{Demo_Class2
|
|
operator+(Demo_Class2 q);}{Declaration via method.}
|
|
|
|
One can locally activate that the operator declaration is shown as it
|
|
is written without operator formatting, {\tt const ...\&}, classname, or
|
|
trailing const declarations for methods removal. This can be done with
|
|
\verb+\+\verb+ccTagFullDeclarations+ within a scope of braces {\tt
|
|
\{...\}}.
|
|
|
|
\ccTagFullDeclarations
|
|
\ccMethod{Demo_Class2
|
|
operator+(const Demo_Class2& q) const;}{Declaration via method.}
|
|
\ccTagDefaults
|
|
|
|
There is some laziness allowed in placing spaces around the operator
|
|
characters. See the following examples:
|
|
|
|
\ccMethod{A
|
|
operator+(Demo_Class2 q);}{\CC\ code: {\tt A operator+(Demo\_Class2 q);}}
|
|
\ccGlue
|
|
\ccMethod{A
|
|
operator +(Demo_Class2 q);}{\CC\ code: {\tt A operator +(Demo\_Class2 q);}}
|
|
\ccGlue
|
|
\ccMethod{A
|
|
operator+ (Demo_Class2 q);}{\CC\ code: {\tt A operator+ (Demo\_Class2 q);}}
|
|
\ccGlue
|
|
\ccMethod{A
|
|
operator + (Demo_Class2 q);}{\CC\ code:
|
|
{\tt A operator + (Demo\_Class2 q);}}
|
|
|
|
The keyword {\tt operator} is reserved, but it can appear as a
|
|
substring in another name. See the following examples that this
|
|
style can handle such cases:
|
|
|
|
\ccMethod{A foo_operator(Demo_Class2 q);}{}
|
|
\ccGlue
|
|
\ccMethod{A noperator(Demo_Class2 q);}{}
|
|
\ccGlue
|
|
\ccMethod{A operatoro(Demo_Class2 q);}{}
|
|
\ccGlue
|
|
\ccMethod{A operator_(Demo_Class2 q);}{}
|
|
\ccGlue
|
|
\ccMethod{A operator0(Demo_Class2 q);}{}
|
|
|
|
A problem has occured in detecting the operator keyword if it was
|
|
directly preceded by an {\tt \&} or {\tt *} character. It is fixed as
|
|
the following example demonstrates:
|
|
|
|
\ccFunction{Int &operator+=( Int a, Int b);}{}
|
|
|
|
\end{ccClass}
|
|
|
|
%----------------------------------------------------------------------
|
|
\ccTagDefaults
|
|
\begin{ccClass}{ClassA}
|
|
\section{The List of All Operators}
|
|
|
|
\ccFunction{Ptr_Class
|
|
operator->(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator[](ClassA p, int i);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator()(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator()(ClassA p, int i);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator()(ClassA p, int i, int j);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator()(ClassA p, int i, int j, int k);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator()(ClassA p,
|
|
const A& a, B& b, C c, const D& d, ClassA
|
|
e);}{all number and types of parameters are possible.}
|
|
|
|
\ccFunction{ClassA
|
|
operator++(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator++(ClassA p, int);}{The postfix incr.\ operator
|
|
has a hidden {\tt int} parameter that the formatting does not show.}
|
|
|
|
\ccFunction{ClassA
|
|
operator--(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator--(ClassA p, int);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator~(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator!(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator-(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator+(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator&(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator*(ClassA p);}{}
|
|
|
|
\ccMethod{ void*
|
|
operator new( size_t);}{Hidden parameters are not shown. \CC\ code:
|
|
$\backslash${\tt method\{ void* operator new( size\_t);\}}.}
|
|
|
|
\ccMethod{ void
|
|
operator delete( void*, size_t);}{Hidden parameters are not shown.
|
|
\CC\ code: $\backslash${\tt method\{ void operator
|
|
delete( void*, size\_t);\}}}
|
|
|
|
\ccMethod{ void
|
|
operator delete[]( void*, size_t);}{Hidden parameters are not
|
|
shown again.
|
|
\CC\ code: $\backslash${\tt method\{ void operator
|
|
delete[]( void*, size\_t);\}}}
|
|
|
|
\ccFunction{Member_Ptr
|
|
operator->*(ClassA p);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator*(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator/(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator%(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator+(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator-(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator<<(ClassA p, int i);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator>>(ClassA p, int i);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator<(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator<=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator>(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator>=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator==(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator!=(ClassA p, ClassA q);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator&(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator^(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator|(ClassA p, ClassA q);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator&&(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator||(ClassA p, ClassA q);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator*=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator/=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator%=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator+=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator-=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator<<=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator>>=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator&=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator|=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator^=(ClassA p, ClassA q);}{}
|
|
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Scope Operator in Types}
|
|
|
|
CGAL will use {\tt typedef}'s and the scope operator to define types.
|
|
Here is an example for the scope operator within types. The scope
|
|
operator cannot be used within the function or method name.
|
|
|
|
\ccSetTwoOfThreeColumns{5.8cm}{1.8cm}
|
|
\ccFunction{Rep_Class::Nested_Class
|
|
foo(Rep_Class::Nested_Class p, Demo_Class q);}{
|
|
Declaration with scope.}
|
|
|
|
\ccFunction{Rep_Class :: Nested_Class
|
|
foo(Rep_Class :: Nested_Class p, Demo_Class q);}{
|
|
The same, surrounded by spaces.}
|
|
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClassTemplate}{ClassB<FT<RT> >}
|
|
\ccSection{Demo Class Template}
|
|
|
|
\ccCreation
|
|
\ccCreationVariable{p}
|
|
|
|
\ccTwo{ClassB<FT<RT> > p( A a, B *b);X}{}
|
|
\ccConstructor{ ClassB();}{ default.}
|
|
\ccGlue
|
|
\ccConstructor{ ClassB( ClassB<FT<RT> > q);}{ copy.}
|
|
\ccGlue
|
|
\ccConstructor{ ClassB( A a, B *b);}{ arbitrary.}
|
|
|
|
\ccOperations
|
|
\ccThree{ClassB<FT<RT> >}{foo( q);}{}
|
|
|
|
\ccMethod{ ClassB foo( ClassB q);}{
|
|
wrong, without template parameters.}
|
|
|
|
\ccFunction{ ClassB<FT<RT> > foo( ClassB<FT<RT> > q);}{
|
|
right, with template parameters.}
|
|
\end{ccClassTemplate}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Abbreviations}
|
|
|
|
The math set symbols need the package
|
|
{\tt amssymb} and \LaTeXe.
|
|
|
|
\begin{tabbing}
|
|
\ccTexHtml{dum \= dummyyyyyyyy \= \kill}{}
|
|
\> \verb+\CC+ \> \CC \\
|
|
\> \verb+\gcc+ \> \gcc \\
|
|
\> \verb+\nat+ \> \nat \\
|
|
\> \verb+\real+ \> \real \\
|
|
\> \verb+\leda+ \> \leda \\
|
|
\> \verb+\cgal+ \> \cgal \\
|
|
\> \verb+\protocgal+ \> \protocgal \\
|
|
\> \verb+\plageo+ \> \plageo \\
|
|
\> \verb+\+\verb+N+ \> \N \\
|
|
\> \verb+\+\verb+Z+ \> \Z \\
|
|
\> \verb+\+\verb+R+ \> \R \\
|
|
\> \verb+\+\verb+E+ \> \E
|
|
\end{tabbing}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Enum's}
|
|
|
|
Enum's are formatted similiar to constructors. Exactly one pair of
|
|
matching braces has to be in the declaration.
|
|
|
|
\ccTwo{enum Short ( A, B, C);XX}{}
|
|
|
|
\ccEnum{enum Short { A, B, C};}{ Comment.}
|
|
|
|
\ccEnum{enum Funny_type_name1 { A_couple_of_entries1,
|
|
one_with_initialisation1 = 5, another1 = -3};}{ Comment.}
|
|
|
|
We can even switch the alternative layout on:
|
|
|
|
\def\ccLongParamLayout{\ccTrue}
|
|
|
|
\ccEnum{enum Funny_type_name2 { A_couple_of_entries2,
|
|
one_with_initialisation2 = 5, another2 = -3};}{ Comment.}
|
|
|
|
\def\ccLongParamLayout{\ccFalse}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Variables, Constants and Typedefs}
|
|
|
|
\ccSetTwoOfThreeColumns{3.5cm}{3.5cm}
|
|
|
|
\ccVariable{long int foo4;}{Local variables are possible.}
|
|
|
|
\ccVariable{long int foo5 = 15;}{Initialisation.}
|
|
|
|
\ccVariable{const long int foo6 = 15;}{Make a constant.}
|
|
|
|
\ccTypedef{typedef int integer;}{Simple typedef.}
|
|
|
|
\ccTypedef{typedef List< int> Integer_list;}{Typedef including template
|
|
parameters.}
|
|
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Global Declarations}
|
|
|
|
\ccGlobalFunction{Intersection_type CGAL_intersection_type(
|
|
Polygon_2< R>, Polygon_2< R>);}
|
|
|
|
\ccGlobalEnum{enum global_enum { A_couple_of_entries3,
|
|
one_with_initialisation3 = 5, another3 = -3};}
|
|
|
|
\ccGlobalVariable{int CGAL_global_var;}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClassTemplate}{CGAL_Point_2< R>}
|
|
\section{Default Parameters in Function Argument Lists}
|
|
|
|
The following example demonstrates the new ability to write default
|
|
parameters with initializers in parantheses notion of \CC.
|
|
|
|
\ccCreationVariable{p}
|
|
\ccConstructor{CGAL_Point_2(const R::RT &x, const R::RT &y, const R::RT &w = R::RT(1.0));}{blabla}
|
|
\end{ccClassTemplate}
|
|
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Test Indentation and Alternate Formatting}
|
|
|
|
This example tests the indentation and right margin setting
|
|
possibilities. Two long declarations with alternative formatting rules
|
|
for the function arguments are used. First the declaration without
|
|
any indentation or margins.
|
|
|
|
\ccFunction{int a_really_long_function_name( double paramter1, double
|
|
paramter2);}{the default formatting. A bit more text is necessary to
|
|
demonstrate the right margin.}
|
|
|
|
Now with 10mm indentation and 10mm right margin. Note that the
|
|
description is also further indented since all dimensions are
|
|
calculated from left.
|
|
|
|
\ccTagDefaults
|
|
\def\ind{\hspace*{7mm}}
|
|
\ccTexHtml{\ccwIndent=10mm \ccwRightMargin=10mm}{}
|
|
|
|
\ccFunction{int a_really_long_function_name( double paramter1, double
|
|
paramter2);}{the default formatting. A bit more text is necessary to
|
|
demonstrate the right margin.}
|
|
\renewcommand{\ccLongParamLayout}{\ccTrue}
|
|
|
|
\ccFunction{int a_really_long_function_name( double paramter1, double
|
|
paramter2);}{the alternative formatting. A bit more text is necessary to
|
|
demonstrate the right margin.}
|
|
|
|
Show the indentation also for template functions.
|
|
|
|
\ccFunction{template<class A> int bar(A a);}{A bit more text to
|
|
demonstrate the right margin.}
|
|
|
|
\renewcommand{\ccLongParamLayout}{\ccFalse}
|
|
|
|
Check the same alternate indentation with the compatibility mode
|
|
\verb+\renewcommand{\ccAlternateThreeColumn}{\ccFalse}+
|
|
|
|
\renewcommand{\ccAlternateThreeColumn}{\ccFalse}
|
|
|
|
\ccFunction{int a_really_long_function_name( double paramter1, double
|
|
paramter2);}{the alternative formatting. A bit more text is necessary to
|
|
demonstrate the right margin.}
|
|
|
|
Show the indentation also for template functions.
|
|
|
|
\ccFunction{template<class A> int bar(A a);}{A bit more text to
|
|
demonstrate the right margin.}
|
|
|
|
\renewcommand{\ccAlternateThreeColumn}{\ccTrue}
|
|
\ccTexHtml{\ccwIndent=0mm \ccwRightMargin=0mm}{}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Test the Setting of the Column Widths by Example Texts}
|
|
|
|
|
|
\ccSetThreeColumns{int}{foo( int i, int j);}{}
|
|
\ccFunction{int foo( int i, int j);}{returns gnats$(i,j)$.}
|
|
|
|
\ccSetThreeColumns{int}{}{returns gnats$(i,j)$.}
|
|
\ccFunction{int foo( int i, int j);}{returns gnats$(i,j)$.}
|
|
|
|
\ccSetThreeColumns{}{foo( int i, int j);}{returns gnats$(i,j)$.}
|
|
\ccFunction{int foo( int i, int j);}{returns gnats$(i,j)$.}
|
|
|
|
Test it with the special characters (changed catcodes) for function
|
|
and contructor declarations.
|
|
|
|
|
|
\ccSetThreeColumns{_#_^}{_#_^f*&*&oo( int i);}{}
|
|
\ccSetTwoColumns{_#_^ foo( int i, int j);}{}
|
|
\begin{ccClass}{Gnu1}
|
|
\ccCreationVariable{g}
|
|
\ccConstructor{Gnu1( double d);}{test.}
|
|
\ccFunction{int foo( Gnats<T> gn);}{blablabla.}
|
|
\end{ccClass}
|
|
|
|
Specify a column layout for a function and propagate it to a contructor.
|
|
|
|
\ccSetThreeColumns{intM}{foo( Gnats<T> gn);M}{}
|
|
\ccPropagateThreeToTwoColumns
|
|
\begin{ccClass}{Gnu2}
|
|
\ccCreationVariable{g}
|
|
\ccConstructor{Gnu2( double d);}{test.}
|
|
\ccFunction{int foo( Gnats<T> gn);}{blablabla.}
|
|
\end{ccClass}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Check Long Constructor Calls}
|
|
|
|
\begin{ccClassTemplate}{CBP_Bidirectional_circulator< C, C*
|
|
(C::*next)(), C* (C::*previous)()>}
|
|
\ccCreationVariable{circ}
|
|
\ccSetTwoColumns{}{a const circulator \ccVar\ with singular value.}
|
|
|
|
NOTHING is interesting here.
|
|
|
|
|
|
\ccConstructor{CBP_Bidirectional_circulator();}{%
|
|
a const circulator \ccVar\ with singular value.}
|
|
|
|
\ccConstructor{CBP_Bidirectional_circulator( const C* ptr);}{a
|
|
const circulator \ccVar\ initialized to point to the element \ccStyle{*ptr}.}
|
|
\end{ccClassTemplate}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Glueing Declarations Together}
|
|
|
|
\ccFunction{int foo( double x);}{}
|
|
\ccGlue
|
|
\ccFunction{int bar( double x);}{}
|
|
|
|
\ccFunction{int foo( double x);}{Bla.}
|
|
\ccGlue
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
|
|
\ccFunction{int foo_baaaaaaaarrrr( double x);}{%
|
|
Bla bal blabal blabal blabal blab.}
|
|
\ccGlue
|
|
\ccFunction{int barfoooooooooooooooooo( double x);}{%
|
|
Blubb blubblubb blubblubb blubblubb blubb.}
|
|
|
|
\ccFunction{int foo_baaaaaaaarrrr( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal blab.}
|
|
\ccGlue
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
|
|
\ccFunction{int foo_bar( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal blab.}
|
|
\ccGlue
|
|
\ccFunction{int foo_bar( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bkuuhd kjwdhwkjdhh blab.}
|
|
\ccGlue
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Glueing Declarations Together, New Style}
|
|
|
|
%\parskip0pt
|
|
|
|
\ccGlueBegin
|
|
\ccFunction{int foo( double x);}{}
|
|
\ccFunction{int bar( double x);}{}
|
|
\ccGlueEnd
|
|
|
|
\ccGlueBegin
|
|
\ccFunction{int foo( double x);}{Bla.}
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
\ccGlueEnd
|
|
|
|
\ccGlueBegin
|
|
\ccFunction{int foo_baaaaaaaarrrr( double x);}{%
|
|
Bla bal blabal blabal blabal blab.}
|
|
\ccFunction{int barfoooooooooooooooooo( double x);}{%
|
|
Blubb blubblubb blubblubb blubblubb blubb.}
|
|
\ccGlueEnd
|
|
|
|
\ccGlueBegin
|
|
\ccFunction{int foo_baaaaaaaarrrr( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal blab.}
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
\ccGlueEnd
|
|
|
|
\ccGlueBegin
|
|
\ccFunction{int foo_bar( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal blab.}
|
|
\ccFunction{int foo_bar( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bkuuhd kjwdhwkjdhh blab.}
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
\ccGlueEnd
|
|
|
|
A bit text thereafter.
|
|
|
|
A new paragraph to check that \verb+\parskip+ gets restored properly.
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{Base::Derived}
|
|
\section{Nested Classes}
|
|
|
|
First try, use the scope operator in the class name.
|
|
|
|
\ccCreationVariable{a}
|
|
|
|
\ccConstructor{Base::Derived( double x);}{a constructor.}
|
|
\ccFunction{Base::Derived foo( Base::Derived b);}{a function.}
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Prefix Substitution}
|
|
|
|
The example illustrates both typical usages (with a fantasy function
|
|
that does not exist in \cgal).
|
|
|
|
\ccSetThreeColumns{CGAL_Point<R>}{CGAL_f( CGAL_Vector<R> v)}{}
|
|
|
|
\ccStyle{#include <CGAL/point.h>}
|
|
\\
|
|
\ccFunction{CGAL_Point<R> CGAL_f( CGAL_Vector<R> v);}{%
|
|
the original \cgal\ prefix.}
|
|
\vspace{-\parskip}
|
|
|
|
\begin{tabbing}
|
|
\ccTexHtml{CCimplementationNNNMMMMMMMMMMMMMMMMMMMM \= ImplementationMMMMM \= \kill}{}
|
|
\verb+\def\ccTargetPrefix{}+ \\
|
|
\verb+\renewcommand{\ccTagReplacePrefix}{\ccTrue}+
|
|
\end{tabbing}
|
|
\def\ccTargetPrefix{}
|
|
\renewcommand{\ccTagReplacePrefix}{\ccTrue}
|
|
\vspace{-\parskip}
|
|
|
|
\ccStyle{#include <CGAL/point.h>}
|
|
\\
|
|
\ccFunction{CGAL_Point<R> CGAL_f( CGAL_Vector<R> v);}{%
|
|
assuming name spaces. {\tt ;-)}}
|
|
\vspace{-\parskip}
|
|
|
|
\begin{tabbing}
|
|
\ccTexHtml{CCimplementationNNNMMMMMMMMMMMMMMMMMMMM \= ImplementationMMMMM \= \kill}{}
|
|
\verb+\def\ccTargetPrefix{GTE}+ \\
|
|
\verb+\renewcommand{\ccTagReplaceInclude}{\ccTrue}+
|
|
\end{tabbing}
|
|
\def\ccTargetPrefix{GTE}
|
|
\renewcommand{\ccTagReplaceInclude}{\ccTrue}
|
|
\vspace{-\parskip}
|
|
|
|
\ccStyle{#include <CGAL/point.h>}
|
|
\\
|
|
\ccFunction{CGAL_Point<R> CGAL_f( CGAL_Vector<R> v);}{%
|
|
make a Porsche from this declaration.}
|
|
\vspace{-\parskip}
|
|
|
|
\begin{tabbing}
|
|
\ccTexHtml{CCimplementationNNNMMMMMMMMMMMMMMMMMMMM \= ImplementationMMMMM \= \kill}{}
|
|
\verb+\renewcommand{\ccTagReplacePrefix}{\ccFalse}+ \\
|
|
\verb+\renewcommand{\ccTagReplaceInclude}{\ccFalse}+
|
|
\end{tabbing}
|
|
\renewcommand{\ccTagReplacePrefix}{\ccFalse}
|
|
\renewcommand{\ccTagReplaceInclude}{\ccFalse}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{A Constructor for a Nested Class}
|
|
|
|
The method how it should work:
|
|
|
|
\begin{ccClass}{CGAL_SegmentTree_2d<T1>::SegTree}
|
|
|
|
The classname is \ccClassTemplateName.
|
|
|
|
\ccCreationVariable{t}
|
|
\ccConstructor{CGAL_SegmentTree_2d<T1>::SegTree
|
|
(S2dList::const_iterator first);}{constructor.}
|
|
|
|
\ccMemberFunction{CGAL_SegmentTree_2d<T1>::SegTree
|
|
foo (CGAL_SegmentTree_2d<T1>::SegTree same);}{%
|
|
removal of own type in parameterlist of a member function.}
|
|
\end{ccClass}
|
|
|
|
|
|
The hack I have recommended previously.
|
|
|
|
\ccFunction{CGAL_SegmentTree_2d<T1>::SegTree
|
|
t(S2dList::const_iterator first);}{fake constructor.}
|
|
|
|
Another check with the trouble making operator in a member function.
|
|
|
|
\begin{ccClass}{ClassC}
|
|
\ccCreationVariable{pp}
|
|
\ccMethod{ClassC operator+(ClassC qq);}{%
|
|
Declaration of an operator as a member function.}
|
|
\end{ccClass}
|
|
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Font Changes within a Declaration}
|
|
|
|
In an simple \verb+\ccc{}+ macro: \ccc{var_\tt k_th\ccFont _foo8;} and
|
|
boldface: \ccc{var_\bf k_th\ccFont _foo8;}
|
|
|
|
A global variable declaration.
|
|
|
|
\ccSetThreeColumns{\tt k_th\ccFont _dim\ }{\tt k_th\ccFont _foo8;}{}
|
|
\ccVariable{\tt k_th\ccFont _dim \tt k_th\ccFont _foo8;}{%
|
|
a {\tt k\_th}-dimensional variable.}
|
|
|
|
A constructor and a member function within a class where the classname
|
|
also uses font changing macros.
|
|
|
|
\def\ccTagRmEigenClassName{\ccFalse}
|
|
|
|
\begin{ccClass}{\tt k_th\ccFont _dim_Class}
|
|
\ccCreationVariable{v}
|
|
\ccSetThreeColumns{\tt k_th\ccFont _dim_retvalue\ }{v.k_th\ccFont
|
|
_dim_foo( \tt k_th\ccFont _dim_param)\ ;}{}
|
|
\ccSetTwoColumns{\tt k_th\ccFont _dim_Class v( \tt k_th\ccFont
|
|
_dim_param) \ ;}{}
|
|
\ccConstructor{\tt k_th\ccFont _dim_Class();}{The default constructor.}
|
|
\ccConstructor{\tt k_th\ccFont _dim_Class( \tt k_th\ccFont
|
|
_dim_param);}{The custom constructor.}
|
|
\ccMemberFunction{\tt k_th\ccFont _dim_retvalue \tt k_th\ccFont
|
|
_dim_foo( \tt k_th\ccFont _dim_param);}{a function.}
|
|
\end{ccClass}
|
|
|
|
\def\ccLongParamLayout{\ccTrue}
|
|
|
|
\begin{ccClassTemplate}{CGAL_Segment_tree_\tt k\ccFont <_T1, _C1, _T2,
|
|
_C2,\dots, _T\tt k\ccFont , _C\tt k\ccFont , _V>}
|
|
|
|
\ccCreationVariable{s}
|
|
\ccThree{void}{Dummy}{}
|
|
|
|
\ccConstructor{CGAL_Segment_tree_\tt k\ccFont <_T1, _C1, _T2,
|
|
_C2,\dots, _T\tt k\ccFont , _C\tt k\ccFont ,
|
|
_V>();}{Creation of a {\tt k}-dimensional Segment
|
|
Tree, where the i-th coordinate has type \ccStyle{_Ti} and a
|
|
comparator of type \ccStyle{_Ci}. Parameter type
|
|
\ccStyle{Value} is set to \ccStyle{_V}.}
|
|
|
|
|
|
\ccMethod{void Segment_tree_\tt k\ccFont
|
|
.window_query(GIS_interval_data_\tt k \ccFont
|
|
win, back_insert_iterator<GIS_interval_data_list_\tt k\ccFont> out);}{%
|
|
All elements that
|
|
intersect the associated $d$-dimensional half open interval of
|
|
\ccStyle{win} are placed in the list of \ccStyle{out}.}
|
|
|
|
\end{ccClassTemplate}
|
|
\def\ccLongParamLayout{\ccFalse}
|
|
\def\ccTagRmEigenClassName{\ccTrue}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{ClassD}
|
|
\section{Customization Tags for the Style}
|
|
|
|
\ccThree{ClassD}{pp.operator+( const ClassD& qq) const;}{}
|
|
First, a declaration with all default substitution rule active.
|
|
|
|
\ccCreationVariable{pp}
|
|
|
|
\ccMemberFunction{ClassD operator+(const ClassD& qq) const;}{%
|
|
member function.}
|
|
|
|
Second, all rules switched off.
|
|
\ccTagFullDeclarations
|
|
|
|
\ccMemberFunction{ClassD operator+(const ClassD& qq) const;}{%
|
|
member function.}
|
|
|
|
Third, back to the default.
|
|
\ccTagDefaults
|
|
|
|
\ccMemberFunction{ClassD operator+(const ClassD& qq) const;}{%
|
|
member function.}
|
|
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{Dummy}
|
|
\section{Test the removal or inlining of template declarations}
|
|
\ccCreationVariable{q}
|
|
|
|
Inlining of template declarations. The default is to format the
|
|
template declaration in an extra line. Here the default with a struct
|
|
and a global function.
|
|
|
|
\ccSetThreeColumns{template <class T> T*}{X}{}
|
|
\ccSetTwoColumns{template <class T> struct circulator_base \{\};}{}
|
|
\ccStruct{template <class T>
|
|
struct circulator_base1 {};}{forward.}
|
|
|
|
\ccConstructor{template <class T>
|
|
Dummy();}{constructor.}
|
|
|
|
\ccGlobalFunction{template <class T>
|
|
T* value_type( const circulator_base<T>&);}
|
|
|
|
Here with the inlining on.
|
|
|
|
\def\ccTagTemplateInline{\ccTrue}
|
|
\ccStruct{template <class T>
|
|
struct circulator_base2 {};}{forward.}
|
|
|
|
\ccConstructor{template <class T>
|
|
Dummy();}{constructor.}
|
|
|
|
\ccGlobalFunction{template <class T>
|
|
T* value_type( const circulator_base<T>&);}
|
|
\def\ccTagTemplateInline{\ccFalse}
|
|
|
|
Here with the removal on.
|
|
|
|
\def\ccTagRmTemplate{\ccTrue}
|
|
\ccStruct{template <class T>
|
|
struct circulator_base3 {};}{forward.}
|
|
|
|
\ccConstructor{template <class T>
|
|
Dummy();}{constructor.}
|
|
|
|
\ccGlobalFunction{template <class T>
|
|
T* value_type( const circulator_base<T>&);}
|
|
\def\ccTagRmTemplate{\ccFalse}
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClassTemplate}{Demo<T>}
|
|
\section{A Function Pointer as an Operator Argument}
|
|
|
|
\ccCreationVariable{out}
|
|
\ccThree{Ascii_ostream&}{out << ostream& (*f)(ostream&);}{}
|
|
\ccThreeToTwo
|
|
|
|
\ccMethod{Ascii_ostream& operator<<(ostream& (*f)(ostream&));}
|
|
{manipulators in streams.}
|
|
|
|
\end{ccClassTemplate}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Long Class Template Names in Nested Types}
|
|
|
|
|
|
\begin{ccClassTemplate}{CGAL_tree_point_interface1<P, W, Key,
|
|
Left, Right, Comp>}
|
|
\ccNestedType{Tree_Point}{complies to the container \ccStyle{Point}.}
|
|
\end{ccClassTemplate}
|
|
|
|
If the class does not fit any longer in one line, it wraps around.
|
|
|
|
\begin{ccClassTemplate}{CGAL_tree_point_interface2<Point, Window, Key,
|
|
Point_func, Window_left_func,
|
|
Window_right_func, Compare>}
|
|
\ccNestedType{Tree_Point}{complies to the container \ccStyle{Point}.}
|
|
\end{ccClassTemplate}
|
|
|
|
The formatting for long parameter lists put the new type name in an extra line.
|
|
|
|
\begin{ccClassTemplate}{CGAL_tree_point_interface3<Point, Window, Key,
|
|
Point_func, Window_left_func,
|
|
Window_right_func, Compare>}
|
|
\def\ccLongParamLayout{\ccTrue}
|
|
\ccNestedType{Tree_Point}{complies to the container \ccStyle{Point}.}
|
|
\def\ccLongParamLayout{\ccFalse}
|
|
\end{ccClassTemplate}
|
|
|
|
The proposed solution uses a typedef to avoid duplicating the long
|
|
template class name all over the specification.
|
|
|
|
\begin{ccClass}{Point_interface}
|
|
|
|
The following line must be done by hand if it should be
|
|
formatted more nicely.
|
|
|
|
\ccStyle{typedef CGAL_tree_point_interface<Point, Window, Key,
|
|
Point_func, Window_left_func,
|
|
Window_right_func, Compare> Point_interface;}
|
|
|
|
Since here the specification is written in terms of the above
|
|
\ccStyle{typedef}.
|
|
|
|
\ccNestedType{Tree_Point}{complies to the container \ccStyle{Point}.}
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{HTML Conversion}
|
|
|
|
Small spaces in math mode: $a\:b\;c\!d$.
|
|
|
|
The \verb+\ccc+ macro within a math environment: $1 + 3 - \ccc{symbol} = 8$.
|
|
|
|
A simple class I with a short single character name. No cross linking rules
|
|
|
|
\begin{ccClassTemplate}{I<X>}
|
|
\ccCreationVariable{i}
|
|
\ccConstructor{I(I<X> j);}{}
|
|
\end{ccClassTemplate}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Switch Off Linking and Indexing}
|
|
|
|
\ccThree{boolx}{a.link5( LinkB a, B b)}{}
|
|
\ccThreeToTwo
|
|
|
|
\ccHtmlNoClassIndex\ccHtmlNoLinks
|
|
\begin{ccClass}{LinkA}
|
|
\ccCreationVariable{a}
|
|
|
|
A class \ccClassName\ with \verb+\ccHtmlNoClassIndex+ and
|
|
\verb+\ccHtmlNoLinks+ to suppress cross linking:
|
|
|
|
\ccFunction{
|
|
bool link1(const LinkA& a, const B& b);}{%
|
|
a function is still indexed.
|
|
}
|
|
\ccGlue
|
|
\ccMethod{
|
|
bool link2(const LinkA& a, const B& b);}{%
|
|
a method is never indexed.
|
|
}
|
|
\ccGlue
|
|
\ccStruct{struct LocalX {};}{a nested struct is not indexed.}
|
|
\end{ccClass}
|
|
|
|
|
|
\begin{ccClass}{LinkB}
|
|
\ccCreationVariable{b}
|
|
|
|
A class \ccClassName\ without \verb+\ccHtmlNoClassIndex+ but the individual
|
|
declarations are prefixed with \verb+\ccHtmlNoIndex+ and
|
|
\verb+\ccHtmlNoLinks+:
|
|
|
|
\ccHtmlNoIndex\ccHtmlNoLinks
|
|
\ccFunction{
|
|
bool link3(const LinkB& a, const B& b);}{%
|
|
explicitly not indexed.
|
|
}
|
|
\ccGlue
|
|
\ccMethod{
|
|
bool link4(const LinkB& a, const B& b);}{%
|
|
a method is never indexed.
|
|
}
|
|
\ccGlue
|
|
\ccHtmlNoIndex
|
|
\ccStruct{struct LocalY {};}{a nested struct explicitly not indexed.}
|
|
\end{ccClass}
|
|
|
|
The same for a global function and struct.
|
|
|
|
\ccHtmlNoIndex\ccHtmlNoLinks
|
|
\ccFunction{
|
|
bool link5(const LinkB& a, const B& b);}{%
|
|
explicitly not indexed.
|
|
}
|
|
\ccGlue
|
|
\ccHtmlNoIndex\ccHtmlNoLinks
|
|
\ccStruct{struct GlobalX {};}{a global struct explicitly not indexed and
|
|
not linked.}
|
|
\ccGlue
|
|
\ccStruct{struct GlobalY {};}{a global struct indexed and linked.}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Member Function versus Function for Operators}
|
|
|
|
\begin{ccClass}{CGAL_Geomview_stream}
|
|
\ccCreationVariable{G}
|
|
|
|
\ccFunction{template <class R>
|
|
CGAL_Geomview_stream&
|
|
operator<<(CGAL_Geomview_stream& G,
|
|
const CGAL_Point_2<R>& p);}
|
|
{Inserts the point \ccc{p} into the stream \ccVar. (global function)}
|
|
|
|
\ccMethod{template <class R>
|
|
CGAL_Geomview_stream&
|
|
operator<<(const CGAL_Point_2<R>& p);}
|
|
{Inserts the point \ccc{p} into the stream \ccVar. (member function)}
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Operators Formatted as Functions}
|
|
\begin{ccClass}{FctClass}
|
|
\ccCreationVariable{f}
|
|
|
|
Use default settings.
|
|
|
|
\ccGlueBegin
|
|
\ccMethod{void method() const;}{Normal Const Method.}
|
|
\ccMethod{void operator+(FctClass b) const;}{Normal Const Operator.}
|
|
\ccMethod{void operator()();}{Empty Fct. Operator.}
|
|
\ccMethod{void operator()(int i);}{Fct. Operator.}
|
|
\ccMethod{void operator()() const;}{Empty Fct. Operator.}
|
|
\ccMethod{void operator()(int i, double d) const;}{Fct. Operator.}
|
|
\ccMethod{operator int();}{Conversion Operator.}
|
|
\ccGlueEnd
|
|
|
|
Format full declarations.
|
|
|
|
\ccTagFullDeclarations
|
|
|
|
\ccGlueBegin
|
|
\ccMethod{void method() const;}{Normal Const Method.}
|
|
\ccMethod{void operator+(FctClass b) const;}{Normal Const Operator.}
|
|
\ccMethod{void operator()();}{Empty Fct. Operator.}
|
|
\ccMethod{void operator()(int i);}{Fct. Operator.}
|
|
\ccMethod{void operator()() const;}{Empty Fct. Operator.}
|
|
\ccMethod{void operator()(int i, double d) const;}{Fct. Operator.}
|
|
\ccMethod{operator int();}{Conversion Operator.}
|
|
\ccGlueEnd
|
|
|
|
\ccTagDefaults
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Verbatim Environment}
|
|
|
|
\begin{verbatim}
|
|
int x; // Blabal lkjhdfls hf.s //
|
|
int i; // This is an int. //
|
|
double d; // Double. //
|
|
\end{verbatim}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\end{document}
|
|
|
|
% EOF %
|
|
|
|
|
|
|
|
|