% ---------------------------------------------------------------------- % 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 > fct_foo( const X &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 &t) const; }{ Longish declarations forces the comment to start in the next line.} \ccMethod{Demo_Class1 longish_function_name( const CGAL_Aff_transformation &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() 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 >} \ccSection{Demo Class Template} \ccCreation \ccCreationVariable{p} \ccTwo{ClassB > p( A a, B *b);X}{} \ccConstructor{ ClassB();}{ default.} \ccGlue \ccConstructor{ ClassB( ClassB > q);}{ copy.} \ccGlue \ccConstructor{ ClassB( A a, B *b);}{ arbitrary.} \ccOperations \ccThree{ClassB >}{foo( q);}{} \ccMethod{ ClassB foo( ClassB q);}{ wrong, without template parameters.} \ccFunction{ ClassB > foo( ClassB > 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 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 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 gn);}{blablabla.} \end{ccClass} Specify a column layout for a function and propagate it to a contructor. \ccSetThreeColumns{intM}{foo( Gnats gn);M}{} \ccPropagateThreeToTwoColumns \begin{ccClass}{Gnu2} \ccCreationVariable{g} \ccConstructor{Gnu2( double d);}{test.} \ccFunction{int foo( Gnats 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}{CGAL_f( CGAL_Vector v)}{} \ccStyle{#include } \\ \ccFunction{CGAL_Point CGAL_f( CGAL_Vector 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 } \\ \ccFunction{CGAL_Point CGAL_f( CGAL_Vector 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 } \\ \ccFunction{CGAL_Point CGAL_f( CGAL_Vector 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::SegTree} The classname is \ccClassTemplateName. \ccCreationVariable{t} \ccConstructor{CGAL_SegmentTree_2d::SegTree (S2dList::const_iterator first);}{constructor.} \ccMemberFunction{CGAL_SegmentTree_2d::SegTree foo (CGAL_SegmentTree_2d::SegTree same);}{% removal of own type in parameterlist of a member function.} \end{ccClass} The hack I have recommended previously. \ccFunction{CGAL_SegmentTree_2d::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 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 T*}{X}{} \ccSetTwoColumns{template struct circulator_base \{\};}{} \ccStruct{template struct circulator_base1 {};}{forward.} \ccConstructor{template Dummy();}{constructor.} \ccGlobalFunction{template T* value_type( const circulator_base&);} Here with the inlining on. \def\ccTagTemplateInline{\ccTrue} \ccStruct{template struct circulator_base2 {};}{forward.} \ccConstructor{template Dummy();}{constructor.} \ccGlobalFunction{template T* value_type( const circulator_base&);} \def\ccTagTemplateInline{\ccFalse} Here with the removal on. \def\ccTagRmTemplate{\ccTrue} \ccStruct{template struct circulator_base3 {};}{forward.} \ccConstructor{template Dummy();}{constructor.} \ccGlobalFunction{template T* value_type( const circulator_base&);} \def\ccTagRmTemplate{\ccFalse} \end{ccClass} % ---------------------------------------------------------------------- \begin{ccClassTemplate}{Demo} \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} \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} \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} \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_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} \ccCreationVariable{i} \ccConstructor{I(I 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 CGAL_Geomview_stream& operator<<(CGAL_Geomview_stream& G, const CGAL_Point_2& p);} {Inserts the point \ccc{p} into the stream \ccVar. (global function)} \ccMethod{template CGAL_Geomview_stream& operator<<(const CGAL_Point_2& 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 %