mirror of https://github.com/CGAL/cgal
857 lines
28 KiB
TeX
857 lines
28 KiB
TeX
% ----------------------------------------------------------------------
|
|
% Documentation for the CGAL manual LaTeX style:
|
|
%
|
|
% 16.08.1995 Lutz Kettner
|
|
% ----------------------------------------------------------------------
|
|
% The style is compatible with LaTeX2e, try:
|
|
\documentclass[12pt]{article}
|
|
\usepackage{latexsym}
|
|
\usepackage{amssymb}
|
|
|
|
% LaTeX:
|
|
% \documentstyle[12pt]{article}
|
|
|
|
%\pagestyle{empty}
|
|
\textwidth 15.4cm
|
|
\textheight 24 cm
|
|
\topmargin -14mm
|
|
\evensidemargin 3mm
|
|
\oddsidemargin 3mm
|
|
|
|
\input{cgal_manual.sty}
|
|
|
|
\parindent0em
|
|
\setlength{\parskip}{1ex minus 0.9ex}
|
|
|
|
\sloppy
|
|
|
|
\title {cgal\_manual.sty\\
|
|
The CGAL Kernel User Manual \LaTeX\ style\\
|
|
\vspace{5mm}
|
|
\CCrevision}
|
|
\author{Lutz Kettner}
|
|
|
|
\date{\CCdate}
|
|
|
|
\begin{document}
|
|
|
|
\maketitle
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Introduction}
|
|
|
|
The {\tt cgal\_manual}-style was developed with a tight look at the
|
|
LEDA manual style. It has two facilities. First, it provides a couple
|
|
of macros for structuring the manual as the LEDA manual does. These
|
|
are {\tt \string\CCdefinition}, {\tt \string\CCcreation}, {\tt
|
|
\string\CCoperations}, {\tt \string\CCimplementation}, {\tt
|
|
\string\CCexample}, and {\tt \string\CCprecond}. There are demonstrated
|
|
in the next section.
|
|
|
|
The second facility of this style deals with the special handling of
|
|
\CC\ language features. The style will be used in conjunction with a
|
|
tool that extracts a class declaration with all its method and
|
|
function declarations and plugs it in a \CC\ header file. Therefore,
|
|
pure \CC\ code will stay in several arguments and has to be
|
|
reformatted neatly for the manual. Again, the LEDA manual was the
|
|
ideal we want to meet. In our case, \TeX\ will do the complete
|
|
reformatting as it is written as macros in the style. Another
|
|
section below explains all features. Demo classes with and without
|
|
template parameters are defined.
|
|
|
|
The benefit of using \TeX\ is that no other tool has to be invoked
|
|
before the final specification is printer ready. Thus, no inconsistent
|
|
versions can appear as it is the case e.g.\ for index making
|
|
procedures for \TeX. If the programming turns out to be too slow, I am
|
|
not a \TeX\ wizard, maybe someone can do it better or it can be even
|
|
switched to an external tool.
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Structuring Macros}
|
|
|
|
\CCdefinition Here comes the general introductory explanation for a
|
|
class etc.
|
|
|
|
\CCprecond Specific conditions can be stated as preconditions in any place.
|
|
|
|
\CCcreation Constructors are defined and explained here.
|
|
|
|
\CCoperations The complete list of methods and functions (including
|
|
operators) are defined here.
|
|
|
|
\CCimplementation Specific notes about implementation issues that belong
|
|
to the user can be given here. These might be space requirements and
|
|
runtime statements.
|
|
|
|
\CCexample How to solve a small but interesting problem with this class.
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{CCclass}{Demo_Class}
|
|
\CCsection{A Simple Class}
|
|
|
|
The class with its name is declared by
|
|
\verb"\b"\verb"egin{class}{Demo_Class}".
|
|
For class templates the \verb"\b"\verb"egin{classtemplate}{Demo_Class<...>}"
|
|
environment is designed. See the next section for an example.
|
|
The macro \verb"\"\verb"CCsection{"\ldots\verb"}" produces the section
|
|
title from above and appends the class name. Note that the special
|
|
character ``\_'' has not to be quoted as it is usual within \LaTeX.
|
|
In any case, the complete original \CC\ source text is written
|
|
without quoting. 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:
|
|
\CCstyle{
|
|
#define %^~ Return_Type<Template_Param, X<Y> > fct_foo( const X<Y> &a);}
|
|
|
|
This example is created using the {\verb+\CC+}{\tt style} macro
|
|
that formats its single parameter in this style.
|
|
|
|
To achieve this behavior with \TeX\, the \verb"\catcode" values of
|
|
some characters has to be changed. So within the \CC\ code
|
|
things like comments with ``\%'' sign will not work. Several macros read a
|
|
second parameter with a \TeX\ comment to the declaration. The catcodes
|
|
are restored just before this second parameter. A sad sideeffect is
|
|
that these changed catcodes will not apply if these macros are invoked
|
|
within other macros. In that case, the argument text was just once
|
|
parsed from \TeX\ and the catcodes are all fixed before the catcode
|
|
changing macro expands.
|
|
|
|
\CCdefinition
|
|
|
|
The class \CCclassName\ does nothing. The formatted name of the class
|
|
can be accessed using the macro \verb"\"\verb"classname". The unformatted
|
|
name as it was originally written can be accessed using the
|
|
\verb"\"\verb"pureclassname" macro.
|
|
|
|
\CCcreationVariable{p}
|
|
\CCcreation
|
|
|
|
The constructors create a variable \CCvar\ of the class. The
|
|
\verb"\"\verb"creationvariable{"\ldots\verb"}" macro sets the name for the
|
|
future use. It can be accessed with the \verb"\"\verb"var" or
|
|
\verb"\"\verb"purevar" macro.
|
|
|
|
The constructors are written using the
|
|
\verb"\"\verb"constructor{"\ldots\verb"}{"\ldots\verb"}" macro. The first
|
|
parameter contains the \CC\ declaration, the second parameter the comments.
|
|
The declaration is written in the normal \CC\ fashion, as shown at the end
|
|
of the comment. The style formats them as if they are used
|
|
to declare a variable for this class. For convinience,
|
|
\verb"const"\ldots\verb"&" parameter declarations are eliminated in the
|
|
formatting. It makes no difference in the usage of a parameter. If the
|
|
type of a constructor, method, or function parameter equals the
|
|
current class, it is also omitted. In the case that nothing is left,
|
|
the \CCemptyParameter\ symbol is used. See the copy constructor for an
|
|
example. All together we achieve this natural looking descriptions.
|
|
|
|
\CCstyle{#include< demo_class.h>}
|
|
|
|
\CCconstructor{Demo_Class();}{introduces
|
|
a variable \CCvar\ initialized to the default. \CC\ code:
|
|
{\tt Demo\_Class();}. Test CCstyle: \CCstyle{Underscore\_within
|
|
CCstyle}.}
|
|
|
|
\CCconstructor{Demo_Class( const Demo_Class &);}{copy
|
|
constructor. \CC\ code: {\tt Demo\_Class(const Demo\_Class \&);}}
|
|
|
|
\CCconstructor{Demo_Class( RT hx, RT hy, RT hw);}{arbitrary constructor.
|
|
\CC\ code: {\tt Demo\_Class(RT hx, RT hy, RT hw);}}
|
|
|
|
The font and style in which the declarations are formatted can be
|
|
changed by overwriting the \verb"\CCfont" and \verb"\CCendFont"
|
|
macros. Their default settings are
|
|
\verb"\gdef\CCfont{\it}\gdef\CCendFont{\/}". They are used within a
|
|
group, so font changing commands are local. The rest of this document is
|
|
formatted using the definitions \verb"\gdef\CCfont{\tt}\gdef\CCendFont{}".
|
|
|
|
\gdef\CCfont{\tt}\gdef\CCendFont{}
|
|
\CCconstructor{Demo_Class( int a, X<Y> &x);}{arbitrary constructor.}
|
|
|
|
\gdef\CCfont{\it}\gdef\CCendFont{\/}
|
|
|
|
Also changable are the special characters the formatting has to
|
|
deal with. They are named \verb"\CCunderscore", \verb"\CCopenAngle",
|
|
\verb"\CCcloseAngle", \verb"\CCampersand", \verb"\CChat", and
|
|
\verb"\CCtilde". The symbol for the empty parameter is named
|
|
\verb"\CCemptyParameter".
|
|
|
|
\CCoperations
|
|
\CCsetTwoOfThreeColumns{2.8cm}{2.8cm}
|
|
|
|
The layout of this section can be customized to the width of the
|
|
return types and the declarations. The
|
|
\verb"\"\verb"threecolumns{"\ldots\verb"}{"\ldots\verb"}" macro sets the
|
|
width of the two leading columns of the total three columns. All other
|
|
dimensions will be computed.
|
|
|
|
Note that declarations after the closing parenthesis like {\tt const}
|
|
for the implicit class parameter of a method will not be printed
|
|
(this might change in the future).
|
|
The return value is handled like a parameter type. That means that
|
|
{\tt const\ldots\&} declarations are removed, but if the type equals
|
|
to the class, it is {\em not} removed.
|
|
|
|
\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_Class
|
|
transform( const CGAL_HAff_transformation<FT,RT> &t) const;
|
|
}{ Longish declarations forces the comment to start in
|
|
the next line.}
|
|
|
|
\CCmethod{Demo_Class
|
|
longish_function_name(
|
|
const CGAL_Aff_transformation<FT,RT> &t,
|
|
const Dummy_Type &q,
|
|
Long_Type_Name_For_Fun Variable_Also_Long) const;
|
|
}{ Even more longish declarations forces the parameters printed
|
|
one per line. This was the default formatting.}
|
|
|
|
|
|
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:
|
|
|
|
\CCfunction{Demo_Class& foo( int& a, int* b);}{}
|
|
|
|
\CCfunction{Demo_Class* foo( int& a, int* b);}{}
|
|
|
|
\CCfunction{Demo_Class &foo( int &a, int *b);}{}
|
|
|
|
\CCfunction{Demo_Class *foo( int &a, int *b);}{}
|
|
|
|
Operator declarations are formatted as like the operators are
|
|
used. All operators that are allowed to be overloaded in \CC\ are
|
|
handled. They are listed in the last section for completeness and
|
|
to check the layout.
|
|
|
|
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.
|
|
|
|
\CCfunction{ operator int () const;}{Conversion operator.}
|
|
|
|
\CCfunction{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_Class
|
|
operator+(Demo_Class p, Demo_Class q);}{Declaration via function.}
|
|
|
|
\CCmethod{Demo_Class
|
|
operator+(Demo_Class 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+\C+\verb+CtagFullDeclarations+ within a scope of braces {\tt
|
|
\{...\}}.
|
|
|
|
{\CCtagFullDeclarations
|
|
\CCmethod{Demo_Class
|
|
operator+(const Demo_Class& q) const;}{Declaration via method.}
|
|
}
|
|
|
|
There is some laziness allowed in placing spaces around the operator
|
|
characters. See the following examples:
|
|
|
|
\CCmethod{A
|
|
operator+(Demo_Class q);}{\CC\ code: {\tt A operator+(Demo\_Class q);}}
|
|
|
|
\CCmethod{A
|
|
operator +(Demo_Class q);}{\CC\ code: {\tt A operator +(Demo\_Class q);}}
|
|
|
|
\CCmethod{A
|
|
operator+ (Demo_Class q);}{\CC\ code: {\tt A operator+ (Demo\_Class q);}}
|
|
|
|
\CCmethod{A
|
|
operator + (Demo_Class q);}{\CC\ code: {\tt A operator + (Demo\_Class 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_Class q);}{}
|
|
|
|
\CCmethod{A noperator(Demo_Class q);}{}
|
|
|
|
\CCmethod{A operatoro(Demo_Class q);}{}
|
|
|
|
\CCmethod{A operator_(Demo_Class q);}{}
|
|
|
|
\CCmethod{A operator0(Demo_Class q);}{}
|
|
|
|
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.}
|
|
|
|
\end{CCclass}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{classtemplate}{Demo_Class<FT<RT> >}
|
|
\CCsection{Demo Class Template}
|
|
|
|
This class template is given within a
|
|
\verb"\be"\verb"gin{classtemplate}{Demo_Class<FT<RT> >}" environment.
|
|
|
|
\CCcreationVariable{p}
|
|
\CCcreation
|
|
|
|
A current misbehaviour (or feature?) of the structuring macros is that
|
|
they have fixed numbers. So the \verb"\"\verb"definition" macro is here
|
|
missing.
|
|
|
|
\CCconstructor{ Demo_Class();}{ default.}
|
|
|
|
\CCconstructor{ Demo_Class( Demo_Class<FT<RT> > q);}{ copy.}
|
|
|
|
\CCconstructor{ Demo_Class( A a, B *b);}{ arbitrary.}
|
|
|
|
\CCoperations
|
|
\CCsetTwoOfThreeColumns{4.3cm}{2.3cm}
|
|
|
|
\CCmethod{ Demo_Class foo( Demo_Class q);}{
|
|
wrong, without template parameters.}
|
|
|
|
\CCfunction{ Demo_Class<FT<RT> > foo( Demo_Class<FT<RT> > q);}{
|
|
right, with template parameters.}
|
|
|
|
Another example demonstrating a const pointer declaration of a
|
|
class template.
|
|
|
|
\CCfunction{Demo_Class& foo( const Class< int>* b);}{}
|
|
|
|
\CCfunction{Demo_Class& foo( const Demo_Class< int>* b);}{}
|
|
|
|
\end{classtemplate}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{New Features Introduced with Version 1.8}
|
|
|
|
\begin{CCclass}{Demo_Class}
|
|
|
|
A small set of handy abbreviations are added. Here they are all together:
|
|
|
|
\begin{tabbing}
|
|
dum \= dummyyyyyyyy \= \kill
|
|
\> \verb+\CC+ \> \CC \\
|
|
\> \verb+\gcc+ \> \gcc \\
|
|
\> \verb+\nat+ \> \nat \\
|
|
\> \verb+\real+ \> \real \\
|
|
% \> \verb+\boxit{A}+ \> \boxit{A} \\
|
|
\> \verb+\leda+ \> \leda \\
|
|
\> \verb+\cgal+ \> \cgal \\
|
|
\> \verb+\protocgal+ \> \protocgal \\
|
|
\> \verb+\plageo+ \> \plageo
|
|
\end{tabbing}
|
|
|
|
\def\CCalternateThreeColumn{\CCtrue}
|
|
\CCcreationVariable{p}
|
|
\CCsetTwoOfThreeColumns{2.8cm}{2.8cm}
|
|
|
|
\CCconstructor{Demo_Class( Paramter1 hx,
|
|
Paramter2 hy,
|
|
Paramter3 hw,
|
|
Paramter4 hw,
|
|
Paramter5 hw);}{
|
|
Longish parameter lists will be broken into several lines.
|
|
Therefore, the parameter {\tt $\backslash$CCalternateThreeColumn} was
|
|
set to {\tt $\backslash$CCtrue}.}
|
|
|
|
\def\CCalternateThreeColumn{\CCtrue}
|
|
|
|
\CCmethod{Demo_Class
|
|
longish_naming(
|
|
const DGAL_HAff_transformation<FT,RT> &t,
|
|
const Dummy_Type &q,
|
|
Long_Type_Name Variable_Also_Long) const;
|
|
}{ Here, the alternative formatting was again switched on
|
|
by setting the parameter {\tt
|
|
$\backslash$CCalternateThreeColumn} to {\tt
|
|
$\backslash$CCtrue}.}
|
|
|
|
\CCmethod{Even_a_long_return_value
|
|
longish_naming(
|
|
const DGAL_HAff_transformation<FT,RT> &t,
|
|
const Dummy_Type &q,
|
|
Long_Type_Name Variable_Also_Long) const;
|
|
}{ Now, a long return value forces the function to start
|
|
in the next line.}
|
|
|
|
\def\CCalternateThreeColumn{\CCfalse}
|
|
|
|
Function templates are written with the macro \verb+\fu+\verb+nctiontemplate+
|
|
that has an additional parameter in front for the template
|
|
parameters. They are visible in the manual because the user does not
|
|
see them, but the parameters are necessary for the specification
|
|
checking tool.
|
|
|
|
\CCsetTwoOfThreeColumns{2.8cm}{8.7cm}
|
|
|
|
\CCfunctionTemplate{R}{bool CGAL_is_intersecting( Point< R>, Point<
|
|
R>);}{comment.}
|
|
|
|
Enum's are formatted similiar to constructors. Exactly one pair of
|
|
matching braces has to be in the declaration.
|
|
|
|
\CCenum{enum Short { A, B, C};}{ Comment.}
|
|
|
|
\CCenum{enum Funny_type_name { A_couple_of_entries,
|
|
one_with_initialisation = 5, another = -3};}{ Comment.}
|
|
|
|
We can even switch the alternative layout on:
|
|
|
|
\gdef\CCalternateThreeColumn{\CCtrue}
|
|
|
|
\CCenum{enum Funny_type_name { A_couple_of_entries,
|
|
one_with_initialisation = 5, another = -3};}{ Comment.}
|
|
|
|
\CCsetTwoOfThreeColumns{3.5cm}{3.5cm}
|
|
|
|
\CCvariable{long int foo;}{Local variables are possible.}
|
|
|
|
\CCvariable{long int foo = 15;}{Initialisation.}
|
|
|
|
\CCvariable{const long int foo = 15;}{Make a constant.}
|
|
|
|
\CCtypedef{typedef int integer;}{Simple typedef.}
|
|
|
|
\CCtypedef{typedef List< int> Integer_list;}{Typedef including template
|
|
parameters.}
|
|
|
|
|
|
\end{CCclass}
|
|
|
|
Global functions and other global declarations can be written with the
|
|
normal macros that are used within class declarations. For convenience,
|
|
a set of {\em global\/} macros are provided that omit the last comment
|
|
parameter. Global declarations are usually commented in the lines
|
|
inbetween. So here comes a global function:
|
|
|
|
\CCglobalFunction{CGAL_intersection_type CGAL_Intersection_type(
|
|
Polygon_2< R>, Polygon_2< R>);}The same
|
|
as a function template:
|
|
|
|
\CCglobalFunctionTemplate{R}{CGAL_intersection_type CGAL_Intersection_type(
|
|
Polygon_2< R>, Polygon_2< R>);}A global enum.
|
|
|
|
\CCglobalEnum{enum Funny_type_name { A_couple_of_entries,
|
|
one_with_initialisation = 5, another = -3};}
|
|
|
|
\CCglobalVariable{int CGAL_global;}Thats it.
|
|
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{New Features Introduced with Version 1.9}
|
|
|
|
\begin{CCclass}{Demo_Class}
|
|
|
|
A set of handy abbreviations has been extended. They need the package
|
|
{\tt amssymb} and \LaTeXe.
|
|
|
|
\begin{tabbing}
|
|
dum \= dummyyyyyyyy \= \kill
|
|
\> \verb+\+\verb+N+ \> \N \\
|
|
\> \verb+\+\verb+Z+ \> \Z \\
|
|
\> \verb+\+\verb+R+ \> \R \\
|
|
\> \verb+\+\verb+E+ \> \E
|
|
\end{tabbing}
|
|
|
|
A \verb+\de+\verb+claration+ accepts one parameter. The style will
|
|
ignore it, while the checker tests if it exists one to one in the C++
|
|
code. It is intended for declarations that are somehow implied by the
|
|
surrounded text, but should not be explicitly visible. For example,
|
|
this example is not visible (smile).
|
|
|
|
\CCdeclaration{Some arbitary funny *%&_ looking # C++ code declaration()...}
|
|
|
|
A \verb+\+verb+hidden+ macro can be prepended to each macro with two
|
|
parameters. It will remove the macro and its parameters from the
|
|
manual. Again, the checker tests the macro as usual. Again an
|
|
invisible example.
|
|
|
|
\CChidden\CCfunction{int foo( double d);}{This is a foo function.}
|
|
|
|
If these non visible parts of the code should be made visible once,
|
|
the \verb+\+\verb+CCmakeAllVisible+ macro switches it on. For
|
|
\verb+\+verb+declaration+ the \verb+\+verb+CCstyle+ macro is used. The
|
|
\verb+\+verb+hidden+ macro vanishes simply. The two funny invisible
|
|
examples from above are repeated here.
|
|
|
|
\CCmakeAllVisible
|
|
|
|
\CCdeclaration{Some arbitary funny *%&_ looking # C++ code declaration()...}
|
|
|
|
\CChidden\CCfunction{int foo( double d);}{This is a foo function
|
|
previously hidden.}
|
|
|
|
The following example demonstrates the new ability to write default
|
|
parameters with initializers in parantheses notion of \CC.
|
|
\end{CCclass}
|
|
|
|
\begin{classtemplate}{CGAL_Point_2< R>}
|
|
\CCconstructor{CGAL_Point_2(const R::RT &x, const R::RT &y, const R::RT &w = R::RT(1.0));}{blabla}
|
|
\end{classtemplate}
|
|
|
|
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);}{}
|
|
|
|
%\begin{CCclass}{Demo_class}
|
|
% \CCcreationVariable{demo_var}%
|
|
%
|
|
% \CCconstructor{Demo_class();}{Default constructor creating variable \CCvar.}
|
|
%
|
|
% \end{CCclass}
|
|
|
|
The \verb+\+verb+CCstyle+ macro is not appropriate to format multiple lines
|
|
of \CC\ code. Use other environments like the {\tt cprog} style.
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{New Features Introduced with Version 1.13}
|
|
|
|
A tool called {\tt cgal\_extract\_html} is able to convert the \cgal\
|
|
Kernel Manual in a semi automatic fashion to a fully hyperlinked
|
|
manual in HTML. A couple of new macros are provided to support these
|
|
cases where the automatic coonversion fails, i.e. tables and complex
|
|
mathematical formulas are not handled automatically.
|
|
|
|
Two environments are provided that encapsulates either \TeX\ or HTML
|
|
code. These are
|
|
|
|
\begin{itemize}
|
|
\item
|
|
\verb+\begin{CCtexOnly} ... \end{CCtexOnly}+ for parts only valid
|
|
in \TeX.
|
|
\item
|
|
\verb+\begin{CChtmlOnly} ... \end{CChtmlOnly}+ for parts only valid
|
|
in the HTML manual. Note that this environment modifies the
|
|
catcodes of a couple of characters. So, do not use this
|
|
environment within a parameter of another \TeX\ macro. On the
|
|
other hand, this allows the use of {\em unmatched} parantheses
|
|
and {\em unknown} macros within the HTML text, the special
|
|
characters are meaningless for \TeX.
|
|
\end{itemize}
|
|
|
|
\TeX\ and HTML code can be written together within one macro.
|
|
|
|
\begin{itemize}
|
|
\item
|
|
\verb+\CCtexHtml{ TeX code ... }{ HTML code ...}+
|
|
\end{itemize}
|
|
|
|
For convinience a solution is provided that easily includes
|
|
hyperlinks with URL's in the \TeX\ source. This macro translates to a
|
|
fully HTML anchor with the given URL around the \TeX\ source after the
|
|
\TeX\ source has been converted.
|
|
|
|
\begin{itemize}
|
|
\item
|
|
\verb+\CCanchor{ URL }{ TeX code ... }+
|
|
\end{itemize}
|
|
|
|
%----------------------------------------------------------------------
|
|
\CCtagDefaults
|
|
\begin{CCclass}{Demo_Class}
|
|
\section{The List of All Operators}
|
|
|
|
\CCfunction{Ptr_Class
|
|
operator->(Demo_Class p);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator[](Demo_Class p, int i);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator()(Demo_Class p);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator()(Demo_Class p, int i);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator()(Demo_Class p, int i, int j);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator()(Demo_Class p, int i, int j, int k);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator()(Demo_Class p,
|
|
const A& a, B& b, C c, const D& d, Demo_Class
|
|
e);}{all number and types of parameters are possible.}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator++(Demo_Class p);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator++(Demo_Class p, int);}{The postfix incr.\ operator
|
|
has a hidden {\tt int} parameter that the formatting does not show.}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator--(Demo_Class p);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator--(Demo_Class p, int);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator~(Demo_Class p);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator!(Demo_Class p);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator-(Demo_Class p);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator+(Demo_Class p);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator&(Demo_Class p);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator*(Demo_Class 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->*(Demo_Class p);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator*(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator/(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator%(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator+(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator-(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator<<(Demo_Class p, int i);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator>>(Demo_Class p, int i);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator<(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator<=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator>(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator>=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator==(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator!=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator&(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator^(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator|(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator&&(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator||(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator*=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator/=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator%=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator+=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator-=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator<<=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator>>=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator&=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator|=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\CCfunction{Demo_Class
|
|
operator^=(Demo_Class p, Demo_Class q);}{}
|
|
|
|
\end{CCclass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\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}}
|
|
\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.}
|
|
|
|
\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}
|
|
\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}{Gnu}
|
|
\CCcreationVariable{g}
|
|
\CCconstructor{Gnu( 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}{Gnu}
|
|
\CCcreationVariable{g}
|
|
\CCconstructor{Gnu( double d);}{test.}
|
|
\CCfunction{int foo( Gnats<T> gn);}{blablabla.}
|
|
\end{CCclass}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Check Long Constructor Calls}
|
|
|
|
\begin{classtemplate}{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{classtemplate}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Glueing Declarations Together}
|
|
|
|
\CCfunction{int foo( double x);}{}
|
|
\CCglueDeclarations
|
|
\CCfunction{int bar( double x);}{}
|
|
|
|
\CCfunction{int foo( double x);}{Bla.}
|
|
\CCglueDeclarations
|
|
\CCfunction{int bar( double x);}{Blubb blubb.}
|
|
|
|
\CCfunction{int foo_baaaaaaaarrrr( double x);}{%
|
|
Bla bal blabal blabal blabal blab.}
|
|
\CCglueDeclarations
|
|
\CCfunction{int barfoooooooooooooooooo( double x);}{%
|
|
Blubb blubblubb blubblubb blubblubb blubb.}
|
|
|
|
|
|
|
|
|
|
\end{document}
|
|
|