[Lemon-commits] [lemon_svn] ladanyi: r1897 - in hugo/trunk/src/lemon: . concept
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:48:33 CET 2006
Author: ladanyi
Date: Wed May 18 11:39:06 2005
New Revision: 1897
Modified:
hugo/trunk/src/lemon/concept/graph.h
hugo/trunk/src/lemon/xy.h
Log:
- minor corrections in the docs
- fixed indenting
Modified: hugo/trunk/src/lemon/concept/graph.h
==============================================================================
--- hugo/trunk/src/lemon/concept/graph.h (original)
+++ hugo/trunk/src/lemon/concept/graph.h Wed May 18 11:39:06 2005
@@ -36,61 +36,61 @@
/**************** The full-featured graph concepts ****************/
- /// \brief Modular builded static graph class.
+ /// \brief Modular static graph class.
///
/// It should be the same as the \c StaticGraph class.
class _StaticGraph
: virtual public BaseGraphComponent,
- public IterableGraphComponent, public MappableGraphComponent {
+ public IterableGraphComponent, public MappableGraphComponent {
public:
typedef BaseGraphComponent::Node Node;
typedef BaseGraphComponent::Edge Edge;
template <typename _Graph>
struct Constraints {
- void constraints() {
- checkConcept<IterableGraphComponent, _Graph>();
- checkConcept<MappableGraphComponent, _Graph>();
- }
+ void constraints() {
+ checkConcept<IterableGraphComponent, _Graph>();
+ checkConcept<MappableGraphComponent, _Graph>();
+ }
};
};
- /// \brief Modular builded extendable graph class.
+ /// \brief Modular extendable graph class.
///
/// It should be the same as the \c ExtendableGraph class.
class _ExtendableGraph
: virtual public BaseGraphComponent, public _StaticGraph,
- public ExtendableGraphComponent, public ClearableGraphComponent {
+ public ExtendableGraphComponent, public ClearableGraphComponent {
public:
typedef BaseGraphComponent::Node Node;
typedef BaseGraphComponent::Edge Edge;
template <typename _Graph>
struct Constraints {
- void constraints() {
- checkConcept<_StaticGraph, _Graph >();
- checkConcept<ExtendableGraphComponent, _Graph >();
- checkConcept<ClearableGraphComponent, _Graph >();
- }
+ void constraints() {
+ checkConcept<_StaticGraph, _Graph >();
+ checkConcept<ExtendableGraphComponent, _Graph >();
+ checkConcept<ClearableGraphComponent, _Graph >();
+ }
};
};
- /// \brief Modular builded erasable graph class.
+ /// \brief Modular erasable graph class.
///
/// It should be the same as the \c ErasableGraph class.
class _ErasableGraph
: virtual public BaseGraphComponent, public _ExtendableGraph,
- public ErasableGraphComponent {
+ public ErasableGraphComponent {
public:
typedef BaseGraphComponent::Node Node;
typedef BaseGraphComponent::Edge Edge;
template <typename _Graph>
struct Constraints {
- void constraints() {
- checkConcept<_ExtendableGraph, _Graph >();
- checkConcept<ErasableGraphComponent, _Graph >();
- }
+ void constraints() {
+ checkConcept<_ExtendableGraph, _Graph >();
+ checkConcept<ErasableGraphComponent, _Graph >();
+ }
};
};
@@ -135,33 +135,33 @@
/// from the trivial node iterator.
class Node {
public:
- /// Default constructor
+ /// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
- Node() { }
- /// Copy constructor.
-
- /// Copy constructor.
- ///
- Node(const Node&) { }
-
- /// Invalid constructor \& conversion.
-
- /// This constructor initializes the iterator to be invalid.
- /// \sa Invalid for more details.
- Node(Invalid) { }
- /// Equality operator
-
- /// Two iterators are equal if and only if they point to the
- /// same object or both are invalid.
- bool operator==(Node) const { return true; }
-
- /// Inequality operator
-
- /// \sa operator==(Node n)
- ///
- bool operator!=(Node) const { return true; }
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
+ Node() { }
+ /// Copy constructor.
+
+ /// Copy constructor.
+ ///
+ Node(const Node&) { }
+
+ /// Invalid constructor \& conversion.
+
+ /// This constructor initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ Node(Invalid) { }
+ /// Equality operator
+
+ /// Two iterators are equal if and only if they point to the
+ /// same object or both are invalid.
+ bool operator==(Node) const { return true; }
+
+ /// Inequality operator
+
+ /// \sa operator==(Node n)
+ ///
+ bool operator!=(Node) const { return true; }
};
@@ -172,42 +172,42 @@
/// of nodes in graph \c g of type \c Graph like this:
/// \code
/// int count=0;
- /// for (Graph::NodeIt n(g); n!=INVALID ++n) ++count;
+ /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
/// \endcode
class NodeIt : public Node {
public:
- /// Default constructor
+ /// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
- NodeIt() { }
- /// Copy constructor.
-
- /// Copy constructor.
- ///
- NodeIt(const NodeIt& n) : Node(n) { }
- /// Invalid constructor \& conversion.
-
- /// Initialize the iterator to be invalid.
- /// \sa Invalid for more details.
- NodeIt(Invalid) { }
- /// Sets the iterator to the first node.
-
- /// Sets the iterator to the first node of \c g.
- ///
- NodeIt(const StaticGraph&) { }
- /// Node -> NodeIt conversion.
-
- /// Sets the iterator to the node of \c g pointed by the trivial
- /// iterator n.
- /// This feature necessitates that each time we
- /// iterate the edge-set, the iteration order is the same.
- NodeIt(const StaticGraph& g, const Node& n) { }
- /// Next node.
-
- /// Assign the iterator to the next node.
- ///
- NodeIt& operator++() { return *this; }
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
+ NodeIt() { }
+ /// Copy constructor.
+
+ /// Copy constructor.
+ ///
+ NodeIt(const NodeIt& n) : Node(n) { }
+ /// Invalid constructor \& conversion.
+
+ /// Initialize the iterator to be invalid.
+ /// \sa Invalid for more details.
+ NodeIt(Invalid) { }
+ /// Sets the iterator to the first node.
+
+ /// Sets the iterator to the first node of \c g.
+ ///
+ NodeIt(const StaticGraph&) { }
+ /// Node -> NodeIt conversion.
+
+ /// Sets the iterator to the node of \c g pointed by the trivial
+ /// iterator n.
+ /// This feature necessitates that each time we
+ /// iterate the edge-set, the iteration order is the same.
+ NodeIt(const StaticGraph& g, const Node& n) { }
+ /// Next node.
+
+ /// Assign the iterator to the next node.
+ ///
+ NodeIt& operator++() { return *this; }
};
@@ -217,31 +217,31 @@
///
class Edge {
public:
- /// Default constructor
+ /// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
- Edge() { }
- /// Copy constructor.
-
- /// Copy constructor.
- ///
- Edge(const Edge&) { }
- /// Initialize the iterator to be invalid.
-
- /// Initialize the iterator to be invalid.
- ///
- Edge(Invalid) { }
- /// Equality operator
-
- /// Two iterators are equal if and only if they point to the
- /// same object or both are invalid.
- bool operator==(Edge) const { return true; }
- /// Inequality operator
-
- /// \sa operator==(Node n)
- ///
- bool operator!=(Edge) const { return true; }
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
+ Edge() { }
+ /// Copy constructor.
+
+ /// Copy constructor.
+ ///
+ Edge(const Edge&) { }
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
+ Edge(Invalid) { }
+ /// Equality operator
+
+ /// Two iterators are equal if and only if they point to the
+ /// same object or both are invalid.
+ bool operator==(Edge) const { return true; }
+ /// Inequality operator
+
+ /// \sa operator==(Node n)
+ ///
+ bool operator!=(Edge) const { return true; }
};
/// This iterator goes trough the outgoing edges of a node.
@@ -258,39 +258,39 @@
class OutEdgeIt : public Edge {
public:
- /// Default constructor
+ /// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
- OutEdgeIt() { }
- /// Copy constructor.
-
- /// Copy constructor.
- ///
- OutEdgeIt(const OutEdgeIt& e) : Edge(e) { }
- /// Initialize the iterator to be invalid.
-
- /// Initialize the iterator to be invalid.
- ///
- OutEdgeIt(Invalid) { }
- /// This constructor sets the iterator to first outgoing edge.
-
- /// This constructor set the iterator to the first outgoing edge of
- /// node
- ///@param n the node
- ///@param g the graph
- OutEdgeIt(const StaticGraph&, const Node&) { }
- /// Edge -> OutEdgeIt conversion
-
- /// Sets the iterator to the value of the trivial iterator \c e.
- /// This feature necessitates that each time we
- /// iterate the edge-set, the iteration order is the same.
- OutEdgeIt(const StaticGraph& g, const Edge& e) { }
- ///Next outgoing edge
-
- /// Assign the iterator to the next
- /// outgoing edge of the corresponding node.
- OutEdgeIt& operator++() { return *this; }
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
+ OutEdgeIt() { }
+ /// Copy constructor.
+
+ /// Copy constructor.
+ ///
+ OutEdgeIt(const OutEdgeIt& e) : Edge(e) { }
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
+ OutEdgeIt(Invalid) { }
+ /// This constructor sets the iterator to the first outgoing edge.
+
+ /// This constructor sets the iterator to the first outgoing edge of
+ /// the node.
+ ///@param n the node
+ ///@param g the graph
+ OutEdgeIt(const StaticGraph&, const Node&) { }
+ /// Edge -> OutEdgeIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator \c e.
+ /// This feature necessitates that each time we
+ /// iterate the edge-set, the iteration order is the same.
+ OutEdgeIt(const StaticGraph& g, const Edge& e) { }
+ ///Next outgoing edge
+
+ /// Assign the iterator to the next
+ /// outgoing edge of the corresponding node.
+ OutEdgeIt& operator++() { return *this; }
};
/// This iterator goes trough the incoming edges of a node.
@@ -307,39 +307,39 @@
class InEdgeIt : public Edge {
public:
- /// Default constructor
+ /// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
- InEdgeIt() { }
- /// Copy constructor.
-
- /// Copy constructor.
- ///
- InEdgeIt(const InEdgeIt& e) : Edge(e) { }
- /// Initialize the iterator to be invalid.
-
- /// Initialize the iterator to be invalid.
- ///
- InEdgeIt(Invalid) { }
- /// This constructor sets the iterator to first incoming edge.
-
- /// This constructor set the iterator to the first incoming edge of
- /// node
- ///@param n the node
- ///@param g the graph
- InEdgeIt(const StaticGraph&, const Node&) { }
- /// Edge -> InEdgeIt conversion
-
- /// Sets the iterator to the value of the trivial iterator \c e.
- /// This feature necessitates that each time we
- /// iterate the edge-set, the iteration order is the same.
- InEdgeIt(const StaticGraph&, const Edge&) { }
- /// Next incoming edge
-
- /// Assign the iterator to the next inedge of the corresponding node.
- ///
- InEdgeIt& operator++() { return *this; }
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
+ InEdgeIt() { }
+ /// Copy constructor.
+
+ /// Copy constructor.
+ ///
+ InEdgeIt(const InEdgeIt& e) : Edge(e) { }
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
+ InEdgeIt(Invalid) { }
+ /// This constructor sets the iterator to first incoming edge.
+
+ /// This constructor set the iterator to the first incoming edge of
+ /// the node.
+ ///@param n the node
+ ///@param g the graph
+ InEdgeIt(const StaticGraph&, const Node&) { }
+ /// Edge -> InEdgeIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator \c e.
+ /// This feature necessitates that each time we
+ /// iterate the edge-set, the iteration order is the same.
+ InEdgeIt(const StaticGraph&, const Edge&) { }
+ /// Next incoming edge
+
+ /// Assign the iterator to the next inedge of the corresponding node.
+ ///
+ InEdgeIt& operator++() { return *this; }
};
/// This iterator goes through each edge.
@@ -352,38 +352,36 @@
/// \endcode
class EdgeIt : public Edge {
public:
- /// Default constructor
+ /// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
- EdgeIt() { }
- /// Copy constructor.
-
- /// Copy constructor.
- ///
- EdgeIt(const EdgeIt& e) : Edge(e) { }
- /// Initialize the iterator to be invalid.
-
- /// Initialize the iterator to be invalid.
- ///
- EdgeIt(Invalid) { }
- /// This constructor sets the iterator to first edge.
-
- /// This constructor set the iterator to the first edge of
- /// node
- ///@param g the graph
- EdgeIt(const StaticGraph&) { }
- /// Edge -> EdgeIt conversion
-
- /// Sets the iterator to the value of the trivial iterator \c e.
- /// This feature necessitates that each time we
- /// iterate the edge-set, the iteration order is the same.
- EdgeIt(const StaticGraph&, const Edge&) { }
- ///Next edge
-
- /// Assign the iterator to the next
- /// edge of the corresponding node.
- EdgeIt& operator++() { return *this; }
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
+ EdgeIt() { }
+ /// Copy constructor.
+
+ /// Copy constructor.
+ ///
+ EdgeIt(const EdgeIt& e) : Edge(e) { }
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
+ EdgeIt(Invalid) { }
+ /// This constructor sets the iterator to the first edge.
+
+ /// This constructor sets the iterator to the first edge of \c g.
+ ///@param g the graph
+ EdgeIt(const StaticGraph&) { }
+ /// Edge -> EdgeIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator \c e.
+ /// This feature necessitates that each time we
+ /// iterate the edge-set, the iteration order is the same.
+ EdgeIt(const StaticGraph&, const Edge&) { }
+ ///Next edge
+
+ /// Assign the iterator to the next edge.
+ EdgeIt& operator++() { return *this; }
};
///Gives back the target node of an edge.
@@ -407,16 +405,16 @@
{
public:
- ///\e
- NodeMap(const StaticGraph&) { }
- ///\e
- NodeMap(const StaticGraph&, T) { }
-
- ///Copy constructor
- NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
- ///Assignment operator
- NodeMap& operator=(const NodeMap&) { return *this; }
- // \todo fix this concept
+ ///\e
+ NodeMap(const StaticGraph&) { }
+ ///\e
+ NodeMap(const StaticGraph&, T) { }
+
+ ///Copy constructor
+ NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
+ ///Assignment operator
+ NodeMap& operator=(const NodeMap&) { return *this; }
+ // \todo fix this concept
};
/// Read write map of the edges to type \c T.
@@ -431,15 +429,15 @@
{
public:
- ///\e
- EdgeMap(const StaticGraph&) { }
- ///\e
- EdgeMap(const StaticGraph&, T) { }
- ///Copy constructor
- EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) { }
- ///Assignment operator
- EdgeMap& operator=(const EdgeMap&) { return *this; }
- // \todo fix this concept
+ ///\e
+ EdgeMap(const StaticGraph&) { }
+ ///\e
+ EdgeMap(const StaticGraph&, T) { }
+ ///Copy constructor
+ EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) { }
+ ///Assignment operator
+ EdgeMap& operator=(const EdgeMap&) { return *this; }
+ // \todo fix this concept
};
template <typename _Graph>
@@ -449,9 +447,8 @@
/// An empty non-static graph class.
- /// This class provides everything that \ref StaticGraph
- /// with additional functionality which enables to build a
- /// graph from scratch.
+ /// This class provides everything that \ref StaticGraph does.
+ /// Additionally it enables building graphs from scratch.
class ExtendableGraph : public StaticGraph
{
public:
@@ -486,7 +483,7 @@
/// An empty erasable graph class.
- /// This class is an extension of \ref ExtendableGraph. It also makes it
+ /// This class is an extension of \ref ExtendableGraph. It makes it
/// possible to erase edges or nodes.
class ErasableGraph : public ExtendableGraph
{
Modified: hugo/trunk/src/lemon/xy.h
==============================================================================
--- hugo/trunk/src/lemon/xy.h (original)
+++ hugo/trunk/src/lemon/xy.h Wed May 18 11:39:06 2005
@@ -29,7 +29,7 @@
/// operations.
///
/// The class \ref lemon::BoundingBox "BoundingBox" can be used to determine
-/// the rectangular bounding box a set of \ref lemon::xy "xy"'s.
+/// the rectangular bounding box of a set of \ref lemon::xy "xy"'s.
///
///\author Attila Bernath
@@ -67,81 +67,81 @@
///Gives back the square of the norm of the vector
T normSquare() const {
- return x*x+y*y;
+ return x*x+y*y;
}
///Increments the left hand side by u
xy<T>& operator +=(const xy<T>& u) {
- x += u.x;
- y += u.y;
- return *this;
+ x += u.x;
+ y += u.y;
+ return *this;
}
///Decrements the left hand side by u
xy<T>& operator -=(const xy<T>& u) {
- x -= u.x;
- y -= u.y;
- return *this;
+ x -= u.x;
+ y -= u.y;
+ return *this;
}
///Multiplying the left hand side with a scalar
xy<T>& operator *=(const T &u) {
- x *= u;
- y *= u;
- return *this;
+ x *= u;
+ y *= u;
+ return *this;
}
///Dividing the left hand side by a scalar
xy<T>& operator /=(const T &u) {
- x /= u;
- y /= u;
- return *this;
+ x /= u;
+ y /= u;
+ return *this;
}
///Returns the scalar product of two vectors
T operator *(const xy<T>& u) const {
- return x*u.x+y*u.y;
+ return x*u.x+y*u.y;
}
///Returns the sum of two vectors
xy<T> operator+(const xy<T> &u) const {
- xy<T> b=*this;
- return b+=u;
+ xy<T> b=*this;
+ return b+=u;
}
///Returns the neg of the vectors
xy<T> operator-() const {
- xy<T> b=*this;
- b.x=-b.x; b.y=-b.y;
- return b;
+ xy<T> b=*this;
+ b.x=-b.x; b.y=-b.y;
+ return b;
}
///Returns the difference of two vectors
xy<T> operator-(const xy<T> &u) const {
- xy<T> b=*this;
- return b-=u;
+ xy<T> b=*this;
+ return b-=u;
}
///Returns a vector multiplied by a scalar
xy<T> operator*(const T &u) const {
- xy<T> b=*this;
- return b*=u;
+ xy<T> b=*this;
+ return b*=u;
}
///Returns a vector divided by a scalar
xy<T> operator/(const T &u) const {
- xy<T> b=*this;
- return b/=u;
+ xy<T> b=*this;
+ return b/=u;
}
///Testing equality
bool operator==(const xy<T> &u) const {
- return (x==u.x) && (y==u.y);
+ return (x==u.x) && (y==u.y);
}
///Testing inequality
bool operator!=(xy u) const {
- return (x!=u.x) || (y!=u.y);
+ return (x!=u.x) || (y!=u.y);
}
};
@@ -229,116 +229,116 @@
bool _empty;
public:
- ///Default constructor: an empty bounding box
+ ///Default constructor: creates an empty bounding box
BoundingBox() { _empty = true; }
///Constructing the instance from one point
BoundingBox(xy<T> a) { bottom_left=top_right=a; _empty = false; }
- ///Is there any point added
+ ///Were any points added?
bool empty() const {
- return _empty;
+ return _empty;
}
///Makes the BoundingBox empty
void clear() {
- _empty=1;
+ _empty=1;
}
///Gives back the bottom left corner (if the bounding box is empty, then the return value is not defined)
xy<T> bottomLeft() const {
- return bottom_left;
+ return bottom_left;
}
///Gives back the top right corner (if the bounding box is empty, then the return value is not defined)
xy<T> topRight() const {
- return top_right;
+ return top_right;
}
///Gives back the bottom right corner (if the bounding box is empty, then the return value is not defined)
xy<T> bottomRight() const {
- return xy<T>(top_right.x,bottom_left.y);
+ return xy<T>(top_right.x,bottom_left.y);
}
///Gives back the top left corner (if the bounding box is empty, then the return value is not defined)
xy<T> topLeft() const {
- return xy<T>(bottom_left.x,top_right.y);
+ return xy<T>(bottom_left.x,top_right.y);
}
///Gives back the bottom of the box (if the bounding box is empty, then the return value is not defined)
T bottom() const {
- return bottom_left.y;
+ return bottom_left.y;
}
///Gives back the top of the box (if the bounding box is empty, then the return value is not defined)
T top() const {
- return top_right.y;
+ return top_right.y;
}
///Gives back the left side of the box (if the bounding box is empty, then the return value is not defined)
T left() const {
- return bottom_left.x;
+ return bottom_left.x;
}
///Gives back the right side of the box (if the bounding box is empty, then the return value is not defined)
T right() const {
- return top_right.x;
+ return top_right.x;
}
///Gives back the height of the box (if the bounding box is empty, then the return value is not defined)
T height() const {
- return top_right.y-bottom_left.y;
+ return top_right.y-bottom_left.y;
}
///Gives back the width of the box (if the bounding box is empty, then the return value is not defined)
T width() const {
- return top_right.x-bottom_left.x;
+ return top_right.x-bottom_left.x;
}
///Checks whether a point is inside a bounding box
bool inside(const xy<T>& u){
- if (_empty)
- return false;
- else{
- return ((u.x-bottom_left.x)*(top_right.x-u.x) >= 0 &&
- (u.y-bottom_left.y)*(top_right.y-u.y) >= 0 );
- }
+ if (_empty)
+ return false;
+ else{
+ return ((u.x-bottom_left.x)*(top_right.x-u.x) >= 0 &&
+ (u.y-bottom_left.y)*(top_right.y-u.y) >= 0 );
+ }
}
///Increments a bounding box with a point
BoundingBox& operator +=(const xy<T>& u){
- if (_empty){
- bottom_left=top_right=u;
- _empty = false;
- }
- else{
- if (bottom_left.x > u.x) bottom_left.x = u.x;
- if (bottom_left.y > u.y) bottom_left.y = u.y;
- if (top_right.x < u.x) top_right.x = u.x;
- if (top_right.y < u.y) top_right.y = u.y;
- }
- return *this;
+ if (_empty){
+ bottom_left=top_right=u;
+ _empty = false;
+ }
+ else{
+ if (bottom_left.x > u.x) bottom_left.x = u.x;
+ if (bottom_left.y > u.y) bottom_left.y = u.y;
+ if (top_right.x < u.x) top_right.x = u.x;
+ if (top_right.y < u.y) top_right.y = u.y;
+ }
+ return *this;
}
///Sums a bounding box and a point
BoundingBox operator +(const xy<T>& u){
- BoundingBox b = *this;
- return b += u;
+ BoundingBox b = *this;
+ return b += u;
}
///Increments a bounding box with an other bounding box
BoundingBox& operator +=(const BoundingBox &u){
- if ( !u.empty() ){
- *this += u.bottomLeft();
- *this += u.topRight();
- }
- return *this;
+ if ( !u.empty() ){
+ *this += u.bottomLeft();
+ *this += u.topRight();
+ }
+ return *this;
}
///Sums two bounding boxes
BoundingBox operator +(const BoundingBox& u){
- BoundingBox b = *this;
- return b += u;
+ BoundingBox b = *this;
+ return b += u;
}
};//class Boundingbox
More information about the Lemon-commits
mailing list