From 3bd793a1d2be31001ba1fab3e103a428436d9d50 Mon Sep 17 00:00:00 2001 From: Guido Kanschat Date: Fri, 9 Jan 2004 12:12:27 +0000 Subject: [PATCH] Doc for doxygen git-svn-id: https://svn.dealii.org/trunk@8293 0785d39b-7218-0410-832d-ea1e28bc413d --- deal.II/base/include/base/function.h | 151 +++++++++++------------ deal.II/base/include/base/smartpointer.h | 34 ++--- 2 files changed, 92 insertions(+), 93 deletions(-) diff --git a/deal.II/base/include/base/function.h b/deal.II/base/include/base/function.h index 1f4627967b..93c20a0c3d 100644 --- a/deal.II/base/include/base/function.h +++ b/deal.II/base/include/base/function.h @@ -2,7 +2,7 @@ // $Id$ // Version: $Name$ // -// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal authors +// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal authors // // This file is subject to QPL and may not be distributed // without copyright and license information. Please refer @@ -37,7 +37,7 @@ template class Vector; * * Access to function objects therefore is through the following * methods: - * @begin{verbatim} + * @code * // access to one component at one point * double value (const Point &p, * const unsigned int component = 0) const; @@ -45,11 +45,11 @@ template class Vector; * // return all components at one point * void vector_value (const Point &p, * Vector &value) const; - * @end{verbatim} + * @endcode * * For more efficiency, there are other functions returning one or all * components at a list of points at once: - * @begin{verbatim} + * @code * // access to one component at several points * void value_list (const std::vector > &point_list, * std::vector &value_list, @@ -58,21 +58,21 @@ template class Vector; * // return all components at several points * void vector_value_list (const std::vector > &point_list, * std::vector > &value_list) const; - * @end{verbatim} + * @endcode * * Furthermore, there are functions returning the gradient of the * function at one or several points. * * You will usually only overload those functions you need; the - * functions returning several values at a time (@p{value_list}, - * @p{vector_value_list}, and gradient analoga) will call those - * returning only one value (@p{value}, @p{vector_value}, and gradient + * functions returning several values at a time (value_list(), + * vector_value_list(), and gradient analoga) will call those + * returning only one value (value(), vector_value(), and gradient * analoga), while those ones will throw an exception when called but * not overloaded. * * Note however, that the functions returning all components of the - * function at one or several points (i.e. @p{vector_value}, - * @p{vector_value_list}), will not call the function returning one + * function at one or several points (i.e. vector_value(), + * vector_value_list()), will not call the function returning one * component at one point repeatedly, once for each point and * component. The reason is efficiency: this would amount to too many * virtual function calls. If you have vector-valued functions, you @@ -87,11 +87,11 @@ template class Vector; * * * Support for time dependant functions can be found in the base - * class @p{FunctionTime}. + * class FunctionTime. * - * @em{Note}: if the functions you are dealing with have sizes which - * are a priori known (for example, @p{dim} elements), you might - * consider using the @p{TensorFunction} class instead. + * @note if the functions you are dealing with have sizes which + * are a priori known (for example, dim elements), you might + * consider using the TensorFunction class instead. * * @author Wolfgang Bangerth, 1998, 1999 */ @@ -202,38 +202,37 @@ class Function : public FunctionTime, * given point. * * Be default, this function - * repeatedly calls the other - * @p{operator()} for each - * component separately, to fill - * the output array. + * repeatedly calls value() for + * each component separately, to + * fill the output array. * - * @p{values} shall have the right + * values shall have the right * size beforehand, - * i.e. @p{n_components}. + * i.e. #n_components. */ virtual void vector_value (const Point &p, Vector &values) const; /** - * Set @p{values} to the point + * Set values to the point * values of the specified * component of the function at - * the @p{points}. It is assumed - * that @p{values} already has the + * the points. It is assumed + * that values already has the * right size, i.e. the same - * size as the @p{points} array. + * size as the points array. */ virtual void value_list (const std::vector > &points, std::vector &values, const unsigned int component = 0) const; /** - * Set @p{values} to the point + * Set values to the point * values of the function at the - * @p{points}. It is assumed that - * @p{values} already has the right + * points. It is assumed that + * values already has the right * size, i.e. the same size as - * the @p{points} array, and that + * the points array, and that * all elements be vectors with * the same number of components * as this function has. @@ -258,28 +257,28 @@ class Function : public FunctionTime, std::vector > &gradients) const; /** - * Set @p{gradients} to the + * Set gradients to the * gradients of the specified * component of the function at - * the @p{points}. It is assumed - * that @p{gradients} already has the + * the points. It is assumed + * that gradients already has the * right size, i.e. the same - * size as the @p{points} array. + * size as the points array. */ virtual void gradient_list (const std::vector > &points, std::vector > &gradients, const unsigned int component = 0) const; /** - * Set @p{gradients} to the gradients of - * the function at the @p{points}, + * Set gradients to the gradients of + * the function at the points, * for all components. - * It is assumed that @p{gradients} + * It is assumed that gradients * already has the right size, i.e. - * the same size as the @p{points} array. + * the same size as the points array. * * The outer loop over - * @p{gradients} is over the points + * gradients is over the points * in the list, the inner loop * over the different components * of the function. @@ -289,15 +288,15 @@ class Function : public FunctionTime, /** * Compute the Laplacian of a - * given component at point @p{p}. + * given component at point p. */ virtual double laplacian (const Point &p, const unsigned int component = 0) const; /** * Compute the Laplacian of all - * components at point @p{p} and - * store them in @p{values}. + * components at point p and + * store them in values. */ virtual void vector_laplacian (const Point &p, Vector &values) const; @@ -326,7 +325,7 @@ class Function : public FunctionTime, * not be determined exactly * (for example: what is the * memory consumption of an - * STL @p{std::map} type with a + * STL std::map type with a * certain number of * elements?), this is only * an estimate. however often @@ -392,12 +391,12 @@ class ZeroFunction : public Function Vector &return_value) const; /** - * Set @p{values} to the point values - * of the function at the @p{points}, + * Set values to the point values + * of the function at the points, * for the given component. - * It is assumed that @p{values} + * It is assumed that values * already has the right size, i.e. - * the same size as the @p{points} + * the same size as the points * array. */ virtual void value_list (const std::vector > &points, @@ -405,12 +404,12 @@ class ZeroFunction : public Function const unsigned int component = 0) const; /** - * Set @p{values} to the point values - * of the function at the @p{points}, + * Set values to the point values + * of the function at the points, * for all components. - * It is assumed that @p{values} + * It is assumed that values * already has the right size, i.e. - * the same size as the @p{points} + * the same size as the points * array. */ virtual void vector_value_list (const std::vector > &points, @@ -434,27 +433,27 @@ class ZeroFunction : public Function std::vector > &gradients) const; /** - * Set @p{gradients} to the gradients of - * the function at the @p{points}, + * Set gradients to the gradients of + * the function at the points, * for the given component. - * It is assumed that @p{values} + * It is assumed that values * already has the right size, i.e. - * the same size as the @p{points} array. + * the same size as the points array. */ virtual void gradient_list (const std::vector > &points, std::vector > &gradients, const unsigned int component = 0) const; /** - * Set @p{gradients} to the gradients of - * the function at the @p{points}, + * Set gradients to the gradients of + * the function at the points, * for all components. - * It is assumed that @p{gradients} + * It is assumed that gradients * already has the right size, i.e. - * the same size as the @p{points} array. + * the same size as the points array. * * The outer loop over - * @p{gradients} is over the points + * gradients is over the points * in the list, the inner loop * over the different components * of the function. @@ -470,12 +469,12 @@ class ZeroFunction : public Function * * Obviously, the derivates of this * function are zero, which is why we derive this class from - * @p{ZeroFunction}: we then only have to overload the value functions, + * ZeroFunction: we then only have to overload the value functions, * not all the derivatives. In some way, it would be more obvious to * do the derivation in the opposite direction, i.e. let - * @p{ZeroFunction} be a more specialized version of @p{ConstantFunction}; + * ZeroFunction be a more specialized version of ConstantFunction; * however, this would be less efficient, since we could not make - * use of the fact that the function value of the @p{ZeroFunction} is + * use of the fact that the function value of the ZeroFunction is * known at compile time and need not be looked up somewhere in * memory. * @@ -522,12 +521,12 @@ class ConstantFunction : public ZeroFunction Vector &return_value) const; /** - * Set @p{values} to the point values - * of the function at the @p{points}, + * Set values to the point values + * of the function at the points, * for the given component. - * It is assumed that @p{values} + * It is assumed that values * already has the right size, i.e. - * the same size as the @p{points} + * the same size as the points * array. */ virtual void value_list (const std::vector > &points, @@ -535,12 +534,12 @@ class ConstantFunction : public ZeroFunction const unsigned int component = 0) const; /** - * Set @p{values} to the point values - * of the function at the @p{points}, + * Set values to the point values + * of the function at the points, * for all components. - * It is assumed that @p{values} + * It is assumed that values * already has the right size, i.e. - * the same size as the @p{points} + * the same size as the points * array. */ virtual void vector_value_list (const std::vector > &points, @@ -555,7 +554,7 @@ class ConstantFunction : public ZeroFunction * not be determined exactly * (for example: what is the * memory consumption of an - * STL @p{std::map} type with a + * STL std::map type with a * certain number of * elements?), this is only * an estimate. however often @@ -578,7 +577,7 @@ class ConstantFunction : public ZeroFunction * zero only in one component. * * It is especially useful as a weight function for - * @p{VectorTools::integrate_difference}, where it allows to integrate + * VectorTools::integrate_difference, where it allows to integrate * only one component. * * @author Guido Kanschat, 2000 @@ -606,12 +605,12 @@ class ComponentSelectFunction : public ConstantFunction Vector &return_value) const; /** - * Set @p{values} to the point values - * of the function at the @p{points}, + * Set values to the point values + * of the function at the points, * for all components. - * It is assumed that @p{values} + * It is assumed that values * already has the right size, i.e. - * the same size as the @p{points} + * the same size as the points * array. */ virtual void vector_value_list (const std::vector > &points, @@ -626,7 +625,7 @@ class ComponentSelectFunction : public ConstantFunction * not be determined exactly * (for example: what is the * memory consumption of an - * STL @p{std::map} type with a + * STL std::map type with a * certain number of * elements?), this is only * an estimate. however often diff --git a/deal.II/base/include/base/smartpointer.h b/deal.II/base/include/base/smartpointer.h index 3434c8d5ca..c2c8177dbc 100644 --- a/deal.II/base/include/base/smartpointer.h +++ b/deal.II/base/include/base/smartpointer.h @@ -2,7 +2,7 @@ // $Id$ // Version: $Name$ // -// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal authors +// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal authors // // This file is subject to QPL and may not be distributed // without copyright and license information. Please refer @@ -20,33 +20,33 @@ /** * Smart pointers avoid destruction of an object in use. They can be used just - * like a pointer (i.e. using the @p{*} and @p{->} operators and through casting) + * like a pointer (i.e. using the * and -> operators and through casting) * but make sure that the object pointed to is not deleted in the course of * use of the pointer by signalling the pointee its use. * - * Objects pointed to should inherit @p{Subscriptor} or must implement + * Objects pointed to should inherit Subscriptor or must implement * the same functionality. Null pointers are an exception from this * rule and are allowed, too. * - * @p{SmartPointer} does NOT implement any memory handling! Especially, - * deleting a @p{SmartPointer} does not delete the object. Writing - * @begin{verbatim} + * SmartPointer does NOT implement any memory handling! Especially, + * deleting a SmartPointer does not delete the object. Writing + * @code * SmartPointer t = new T; - * @end{verbatim} + * @endcode * is a sure way to program a memory leak! The secure version is - * @begin{verbatim} + * @code * T* p = new T; * { * SmartPointer t = p; * ... * } * delete p; - * @end{verbatim} + * @endcode * - * Note that a smart pointer can handle @p{const}ness of an object, i.e. - * a @p{SmartPointer} really behaves as if it were a pointer to + * Note that a smart pointer can handle constness of an object, i.e. + * a SmartPointer really behaves as if it were a pointer to * a constant object (disallowing write access when dereferenced), while - * @p{SmartPointer} is a mutable pointer. + * SmartPointer is a mutable pointer. * * @author Guido Kanschat, Wolfgang Bangerth, 1998, 1999, 2000 */ @@ -61,9 +61,9 @@ class SmartPointer /* * Copy constructor for - * @p{SmartPointer}. We do now + * SmartPointer. We do now * copy the object subscribed to - * from @p{tt}, but subscribe + * from tt, but subscribe * ourselves to it again. */ SmartPointer (const SmartPointer &tt); @@ -100,8 +100,8 @@ class SmartPointer SmartPointer & operator= (T *tt); /** - *Assignment operator for - * @p{SmartPointer}. The pointer + * Assignment operator for + * SmartPointer. The pointer * subscribes to the new object * automatically and unsubscribes * to an old one if it exists. @@ -165,7 +165,7 @@ class SmartPointer * used by this class. Note in * particular, that this only * includes the amount of memory - * used by @em{this} object, not + * used by this object, not * by the object pointed to. */ unsigned int memory_consumption () const; -- 2.39.5