# Changeset 1259:8b2d4e5d96e4 in lemon for lemon

Ignore:
Timestamp:
08/07/13 06:55:05 (8 years ago)
Branch:
default
Parents:
1174:a26b90a17c81 (diff), 1257:3e711ee55d31 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Phase:
public
Message:

Merge #294 to branches >=1.2

Location:
lemon
Files:
16 edited

Unmodified
Removed
• ## lemon/concepts/digraph.h

 r956 /// Sets the iterator to the first arc of the given digraph. /// explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); } explicit ArcIt(const Digraph& g) { ::lemon::ignore_unused_variable_warning(g); } /// Sets the iterator to the given arc.
• ## lemon/concepts/digraph.h

 r1257 * This file is a part of LEMON, a generic C++ optimization library. * * Copyright (C) 2003-2009 * Copyright (C) 2003-2010 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). /// \brief Class describing the concept of directed graphs. /// /// This class describes the \ref concept "concept" of the /// immutable directed digraphs. /// This class describes the common interface of all directed /// graphs (digraphs). /// /// Note that actual digraph implementation like @ref ListDigraph or /// @ref SmartDigraph may have several additional functionality. /// Like all concept classes, it only provides an interface /// without any sensible implementation. So any general algorithm for /// directed graphs should compile with this class, but it will not /// run properly, of course. /// An actual digraph implementation like \ref ListDigraph or /// \ref SmartDigraph may have additional functionality. /// /// \sa concept /// \sa Graph class Digraph { private: ///Digraphs are \e not copy constructible. Use DigraphCopy() instead. ///Digraphs are \e not copy constructible. Use DigraphCopy() instead. /// Digraph(const Digraph &) {}; ///\brief Assignment of \ref Digraph "Digraph"s to another ones are ///\e not allowed. Use DigraphCopy() instead. ///Assignment of \ref Digraph "Digraph"s to another ones are ///\e not allowed.  Use DigraphCopy() instead. /// Diraphs are \e not copy constructible. Use DigraphCopy instead. Digraph(const Digraph &) {} /// \brief Assignment of a digraph to another one is \e not allowed. /// Use DigraphCopy instead. void operator=(const Digraph &) {} public: ///\e /// Defalult constructor. /// Defalult constructor. /// /// Default constructor. Digraph() { } /// Class for identifying a node of the digraph /// The node type of the digraph /// This class identifies a node of the digraph. It also serves /// as a base class of the node iterators, /// thus they will convert to this type. /// thus they convert to this type. class Node { public: /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the object to an undefined value. Node() { } /// Copy constructor. Node(const Node&) { } /// Invalid constructor \& conversion. /// This constructor initializes the iterator to be invalid. /// %Invalid constructor \& conversion. /// Initializes the object to be invalid. /// \sa Invalid for more details. Node(Invalid) { } /// Equality operator /// Equality operator. /// /// Two iterators are equal if and only if they point to the /// same object or both are invalid. /// same object or both are \c INVALID. bool operator==(Node) const { return true; } /// Inequality operator /// \sa operator==(Node n) /// /// Inequality operator. bool operator!=(Node) const { return true; } /// Artificial ordering operator. /// To allow the use of digraph descriptors as key type in std::map or /// similar associative container we require this. /// /// \note This operator only have to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. /// Artificial ordering operator. /// /// \note This operator only has to define some strict ordering of /// the nodes; this order has nothing to do with the iteration /// ordering of the nodes. bool operator<(Node) const { return false; } }; /// This iterator goes through each node. /// This iterator goes through each node. /// Its usage is quite simple, for example you can count the number /// of nodes in digraph \c g of type \c Digraph like this: }; /// Iterator class for the nodes. /// This iterator goes through each node of the digraph. /// Its usage is quite simple, for example, you can count the number /// of nodes in a digraph \c g of type \c %Digraph like this: ///\code /// int count=0; /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the iterator to an undefined value. NodeIt() { } /// Copy constructor. /// NodeIt(const NodeIt& n) : Node(n) { } /// Invalid constructor \& conversion. /// Initialize the iterator to be invalid. /// %Invalid constructor \& conversion. /// Initializes 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 Digraph&) { } /// Node -> NodeIt conversion. /// Sets the iterator to the node of \c the digraph pointed by /// the trivial iterator. /// This feature necessitates that each time we /// iterate the arc-set, the iteration order is the same. /// Sets the iterator to the first node of the given digraph. /// explicit NodeIt(const Digraph&) { } /// Sets the iterator to the given node. /// Sets the iterator to the given node of the given digraph. /// NodeIt(const Digraph&, const Node&) { } /// Next node. /// Class for identifying an arc of the digraph /// The arc type of the digraph /// This class identifies an arc of the digraph. It also serves /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the object to an undefined value. Arc() { } /// Copy constructor. /// Arc(const Arc&) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the object to be invalid. /// \sa Invalid for more details. Arc(Invalid) { } /// Equality operator /// Equality operator. /// /// Two iterators are equal if and only if they point to the /// same object or both are invalid. /// same object or both are \c INVALID. bool operator==(Arc) const { return true; } /// Inequality operator /// \sa operator==(Arc n) /// /// Inequality operator. bool operator!=(Arc) const { return true; } /// Artificial ordering operator. /// To allow the use of digraph descriptors as key type in std::map or /// similar associative container we require this. /// /// \note This operator only have to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. /// Artificial ordering operator. /// /// \note This operator only has to define some strict ordering of /// the arcs; this order has nothing to do with the iteration /// ordering of the arcs. bool operator<(Arc) const { return false; } }; /// This iterator goes trough the outgoing arcs of a node. /// Iterator class for the outgoing arcs of a node. /// This iterator goes trough the \e outgoing arcs of a certain node /// of a digraph. /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of outgoing arcs of a node \c n /// in digraph \c g of type \c Digraph as follows. /// in a digraph \c g of type \c %Digraph as follows. ///\code /// int count=0; /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count; /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; ///\endcode class OutArcIt : public Arc { public: /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the iterator to an undefined value. OutArcIt() { } /// Copy constructor. /// OutArcIt(const OutArcIt& e) : Arc(e) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the iterator to be invalid. /// \sa Invalid for more details. OutArcIt(Invalid) { } /// This constructor sets the iterator to the first outgoing arc. /// This constructor sets the iterator to the first outgoing arc of /// the node. /// Sets the iterator to the first outgoing arc. /// Sets the iterator to the first outgoing arc of the given node. /// OutArcIt(const Digraph&, const Node&) { } /// Arc -> OutArcIt conversion /// Sets the iterator to the value of the trivial iterator. /// This feature necessitates that each time we /// iterate the arc-set, the iteration order is the same. /// Sets the iterator to the given arc. /// Sets the iterator to the given arc of the given digraph. /// OutArcIt(const Digraph&, const Arc&) { } ///Next outgoing arc /// Next outgoing arc /// Assign the iterator to the next }; /// This iterator goes trough the incoming arcs of a node. /// Iterator class for the incoming arcs of a node. /// This iterator goes trough the \e incoming arcs of a certain node /// of a digraph. /// Its usage is quite simple, for example you can count the number /// of outgoing arcs of a node \c n /// in digraph \c g of type \c Digraph as follows. /// Its usage is quite simple, for example, you can count the number /// of incoming arcs of a node \c n /// in a digraph \c g of type \c %Digraph as follows. ///\code /// int count=0; /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count; /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; ///\endcode class InArcIt : public Arc { public: /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the iterator to an undefined value. InArcIt() { } /// Copy constructor. /// InArcIt(const InArcIt& e) : Arc(e) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the iterator to be invalid. /// \sa Invalid for more details. InArcIt(Invalid) { } /// This constructor sets the iterator to first incoming arc. /// This constructor set the iterator to the first incoming arc of /// the node. /// Sets the iterator to the first incoming arc. /// Sets the iterator to the first incoming arc of the given node. /// InArcIt(const Digraph&, const Node&) { } /// Arc -> InArcIt conversion /// Sets the iterator to the value of the trivial iterator \c e. /// This feature necessitates that each time we /// iterate the arc-set, the iteration order is the same. /// Sets the iterator to the given arc. /// Sets the iterator to the given arc of the given digraph. /// InArcIt(const Digraph&, const Arc&) { } /// Next incoming arc /// Assign the iterator to the next inarc of the corresponding node. /// /// Assign the iterator to the next /// incoming arc of the corresponding node. InArcIt& operator++() { return *this; } }; /// This iterator goes through each arc. /// This iterator goes through each arc of a digraph. /// Its usage is quite simple, for example you can count the number /// of arcs in a digraph \c g of type \c Digraph as follows: /// Iterator class for the arcs. /// This iterator goes through each arc of the digraph. /// Its usage is quite simple, for example, you can count the number /// of arcs in a digraph \c g of type \c %Digraph as follows: ///\code /// int count=0; /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count; /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count; ///\endcode class ArcIt : public Arc { /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the iterator to an undefined value. ArcIt() { } /// Copy constructor. /// ArcIt(const ArcIt& e) : Arc(e) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the iterator to be invalid. /// \sa Invalid for more details. ArcIt(Invalid) { } /// This constructor sets the iterator to the first arc. /// This constructor sets the iterator to the first arc of \c g. ///@param g the digraph ArcIt(const Digraph& g) { ::lemon::ignore_unused_variable_warning(g); } /// Arc -> ArcIt conversion /// Sets the iterator to the value of the trivial iterator \c e. /// This feature necessitates that each time we /// iterate the arc-set, the iteration order is the same. /// Sets the iterator to the first arc. /// Sets the iterator to the first arc of the given digraph. /// explicit ArcIt(const Digraph& g) { ::lemon::ignore_unused_variable_warning(g); } /// Sets the iterator to the given arc. /// Sets the iterator to the given arc of the given digraph. /// ArcIt(const Digraph&, const Arc&) { } ///Next arc /// Next arc /// Assign the iterator to the next arc. /// ArcIt& operator++() { return *this; } }; ///Gives back the target node of an arc. ///Gives back the target node of an arc. /// /// \brief The source node of the arc. /// /// Returns the source node of the given arc. Node source(Arc) const { return INVALID; } /// \brief The target node of the arc. /// /// Returns the target node of the given arc. Node target(Arc) const { return INVALID; } ///Gives back the source node of an arc. ///Gives back the source node of an arc. /// Node source(Arc) const { return INVALID; } /// \brief Returns the ID of the node. /// \brief The ID of the node. /// /// Returns the ID of the given node. int id(Node) const { return -1; } /// \brief Returns the ID of the arc. /// \brief The ID of the arc. /// /// Returns the ID of the given arc. int id(Arc) const { return -1; } /// \brief Returns the node with the given ID. /// /// \pre The argument should be a valid node ID in the graph. /// \brief The node with the given ID. /// /// Returns the node with the given ID. /// \pre The argument should be a valid node ID in the digraph. Node nodeFromId(int) const { return INVALID; } /// \brief Returns the arc with the given ID. /// /// \pre The argument should be a valid arc ID in the graph. /// \brief The arc with the given ID. /// /// Returns the arc with the given ID. /// \pre The argument should be a valid arc ID in the digraph. Arc arcFromId(int) const { return INVALID; } /// \brief Returns an upper bound on the node IDs. /// \brief An upper bound on the node IDs. /// /// Returns an upper bound on the node IDs. int maxNodeId() const { return -1; } /// \brief Returns an upper bound on the arc IDs. /// \brief An upper bound on the arc IDs. /// /// Returns an upper bound on the arc IDs. int maxArcId() const { return -1; } int maxId(Arc) const { return -1; } /// \brief The opposite node on the arc. /// /// Returns the opposite node on the given arc. Node oppositeNode(Node, Arc) const { return INVALID; } /// \brief The base node of the iterator. /// /// Gives back the base node of the iterator. /// It is always the target of the pointed arc. Node baseNode(const InArcIt&) const { return INVALID; } /// Returns the base node of the given outgoing arc iterator /// (i.e. the source node of the corresponding arc). Node baseNode(OutArcIt) const { return INVALID; } /// \brief The running node of the iterator. /// /// Gives back the running node of the iterator. /// It is always the source of the pointed arc. Node runningNode(const InArcIt&) const { return INVALID; } /// Returns the running node of the given outgoing arc iterator /// (i.e. the target node of the corresponding arc). Node runningNode(OutArcIt) const { return INVALID; } /// \brief The base node of the iterator. /// /// Gives back the base node of the iterator. /// It is always the source of the pointed arc. Node baseNode(const OutArcIt&) const { return INVALID; } /// Returns the base node of the given incomming arc iterator /// (i.e. the target node of the corresponding arc). Node baseNode(InArcIt) const { return INVALID; } /// \brief The running node of the iterator. /// /// Gives back the running node of the iterator. /// It is always the target of the pointed arc. Node runningNode(const OutArcIt&) const { return INVALID; } /// \brief The opposite node on the given arc. /// /// Gives back the opposite node on the given arc. Node oppositeNode(const Node&, const Arc&) const { return INVALID; } /// \brief Reference map of the nodes to type \c T. /// /// Reference map of the nodes to type \c T. /// Returns the running node of the given incomming arc iterator /// (i.e. the source node of the corresponding arc). Node runningNode(InArcIt) const { return INVALID; } /// \brief Standard graph map type for the nodes. /// /// Standard graph map type for the nodes. /// It conforms to the ReferenceMap concept. template class NodeMap : public ReferenceMap { public: ///\e NodeMap(const Digraph&) { } ///\e /// Constructor explicit NodeMap(const Digraph&) { } /// Constructor with given initial value NodeMap(const Digraph&, T) { } private: ///Copy constructor NodeMap(const NodeMap& nm) : NodeMap(const NodeMap& nm) : ReferenceMap(nm) { } ///Assignment operator }; /// \brief Reference map of the arcs to type \c T. /// /// Reference map of the arcs to type \c T. /// \brief Standard graph map type for the arcs. /// /// Standard graph map type for the arcs. /// It conforms to the ReferenceMap concept. template class ArcMap : public ReferenceMap { public: ///\e ArcMap(const Digraph&) { } ///\e /// Constructor explicit ArcMap(const Digraph&) { } /// Constructor with given initial value ArcMap(const Digraph&, T) { } private: ///Copy constructor
• ## lemon/concepts/graph.h

 r956 /// Sets the iterator to the first arc of the given graph. /// explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); } explicit ArcIt(const Graph &g) { ::lemon::ignore_unused_variable_warning(g); } /// Sets the iterator to the given arc. /// OutArcIt(const Graph& n, const Node& g) { ignore_unused_variable_warning(n); ignore_unused_variable_warning(g); ::lemon::ignore_unused_variable_warning(n); ::lemon::ignore_unused_variable_warning(g); } /// Sets the iterator to the given arc. /// InArcIt(const Graph& g, const Node& n) { ignore_unused_variable_warning(n); ignore_unused_variable_warning(g); ::lemon::ignore_unused_variable_warning(n); ::lemon::ignore_unused_variable_warning(g); } /// Sets the iterator to the given arc.
• ## lemon/concepts/graph.h

 r1257 * This file is a part of LEMON, a generic C++ optimization library. * * Copyright (C) 2003-2009 * Copyright (C) 2003-2010 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). ///\ingroup graph_concepts ///\file ///\brief The concept of Undirected Graphs. ///\brief The concept of undirected graphs. #ifndef LEMON_CONCEPTS_GRAPH_H #include #include #include #include /// \ingroup graph_concepts /// /// \brief Class describing the concept of Undirected Graphs. /// \brief Class describing the concept of undirected graphs. /// /// This class describes the common interface of all Undirected /// Graphs. /// This class describes the common interface of all undirected /// graphs. /// /// As all concept describing classes it provides only interface /// without any sensible implementation. So any algorithm for /// undirected graph should compile with this class, but it will not /// Like all concept classes, it only provides an interface /// without any sensible implementation. So any general algorithm for /// undirected graphs should compile with this class, but it will not /// run properly, of course. /// An actual graph implementation like \ref ListGraph or /// \ref SmartGraph may have additional functionality. /// /// The LEMON undirected graphs also fulfill the concept of /// directed graphs (\ref lemon::concepts::Digraph "Digraph /// Concept"). Each edges can be seen as two opposite /// directed arc and consequently the undirected graph can be /// seen as the direceted graph of these directed arcs. The /// Graph has the Edge inner class for the edges and /// the Arc type for the directed arcs. The Arc type is /// convertible to Edge or inherited from it so from a directed /// arc we can get the represented edge. /// The undirected graphs also fulfill the concept of \ref Digraph /// "directed graphs", since each edge can also be regarded as two /// oppositely directed arcs. /// Undirected graphs provide an Edge type for the undirected edges and /// an Arc type for the directed arcs. The Arc type is convertible to /// Edge or inherited from it, i.e. the corresponding edge can be /// obtained from an arc. /// EdgeIt and EdgeMap classes can be used for the edges, while ArcIt /// and ArcMap classes can be used for the arcs (just like in digraphs). /// Both InArcIt and OutArcIt iterates on the same edges but with /// opposite direction. IncEdgeIt also iterates on the same edges /// as OutArcIt and InArcIt, but it is not convertible to Arc, /// only to Edge. /// /// In the sense of the LEMON each edge has a default /// direction (it should be in every computer implementation, /// because the order of edge's nodes defines an /// orientation). With the default orientation we can define that /// the directed arc is forward or backward directed. With the \c /// direction() and \c direct() function we can get the direction /// of the directed arc and we can direct an edge. /// In LEMON, each undirected edge has an inherent orientation. /// Thus it can defined if an arc is forward or backward oriented in /// an undirected graph with respect to this default oriantation of /// the represented edge. /// With the direction() and direct() functions the direction /// of an arc can be obtained and set, respectively. /// /// The EdgeIt is an iterator for the edges. We can use /// the EdgeMap to map values for the edges. The InArcIt and /// OutArcIt iterates on the same edges but with opposite /// direction. The IncEdgeIt iterates also on the same edges /// as the OutArcIt and InArcIt but it is not convertible to Arc just /// to Edge. /// Only nodes and edges can be added to or removed from an undirected /// graph and the corresponding arcs are added or removed automatically. /// /// \sa Digraph class Graph { private: /// Graphs are \e not copy constructible. Use DigraphCopy instead. Graph(const Graph&) {} /// \brief Assignment of a graph to another one is \e not allowed. /// Use DigraphCopy instead. void operator=(const Graph&) {} public: /// \brief The undirected graph should be tagged by the /// UndirectedTag. /// /// The undirected graph should be tagged by the UndirectedTag. This /// tag helps the enable_if technics to make compile time /// Default constructor. Graph() {} /// \brief Undirected graphs should be tagged with \c UndirectedTag. /// /// Undirected graphs should be tagged with \c UndirectedTag. /// /// This tag helps the \c enable_if technics to make compile time /// specializations for undirected graphs. typedef True UndirectedTag; /// \brief The base type of node iterators, /// or in other words, the trivial node iterator. /// /// This is the base type of each node iterator, /// thus each kind of node iterator converts to this. /// More precisely each kind of node iterator should be inherited /// from the trivial node iterator. /// The node type of the graph /// This class identifies a node of the graph. It also serves /// as a base class of the node iterators, /// thus they convert to this type. class Node { public: /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the object to an undefined value. Node() { } /// Copy constructor. Node(const Node&) { } /// Invalid constructor \& conversion. /// This constructor initializes the iterator to be invalid. /// %Invalid constructor \& conversion. /// Initializes the object to be invalid. /// \sa Invalid for more details. Node(Invalid) { } /// Equality operator /// Equality operator. /// /// Two iterators are equal if and only if they point to the /// same object or both are invalid. /// same object or both are \c INVALID. bool operator==(Node) const { return true; } /// Inequality operator /// \sa operator==(Node n) /// /// Inequality operator. bool operator!=(Node) const { return true; } /// Artificial ordering operator. /// To allow the use of graph descriptors as key type in std::map or /// similar associative container we require this. /// /// \note This operator only have to define some strict ordering of /// Artificial ordering operator. /// /// \note This operator only has to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. }; /// This iterator goes through each node. /// This iterator goes through each node. /// Its usage is quite simple, for example you can count the number /// of nodes in graph \c g of type \c Graph like this: /// Iterator class for the nodes. /// This iterator goes through each node of the graph. /// Its usage is quite simple, for example, you can count the number /// of nodes in a graph \c g of type \c %Graph like this: ///\code /// int count=0; /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the iterator to an undefined value. NodeIt() { } /// Copy constructor. /// NodeIt(const NodeIt& n) : Node(n) { } /// Invalid constructor \& conversion. /// Initialize the iterator to be invalid. /// %Invalid constructor \& conversion. /// Initializes 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 Graph&) { } /// Node -> NodeIt conversion. /// Sets the iterator to the node of \c the graph pointed by /// the trivial iterator. /// This feature necessitates that each time we /// iterate the arc-set, the iteration order is the same. /// Sets the iterator to the first node of the given digraph. /// explicit NodeIt(const Graph&) { } /// Sets the iterator to the given node. /// Sets the iterator to the given node of the given digraph. /// NodeIt(const Graph&, const Node&) { } /// Next node. /// The base type of the edge iterators. /// The base type of the edge iterators. /// /// The edge type of the graph /// This class identifies an edge of the graph. It also serves /// as a base class of the edge iterators, /// thus they will convert to this type. class Edge { public: /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the object to an undefined value. Edge() { } /// Copy constructor. /// Edge(const Edge&) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the object to be invalid. /// \sa Invalid for more details. Edge(Invalid) { } /// Equality operator /// Equality operator. /// /// Two iterators are equal if and only if they point to the /// same object or both are invalid. /// same object or both are \c INVALID. bool operator==(Edge) const { return true; } /// Inequality operator /// \sa operator==(Edge n) /// /// Inequality operator. bool operator!=(Edge) const { return true; } /// Artificial ordering operator. /// To allow the use of graph descriptors as key type in std::map or /// similar associative container we require this. /// /// \note This operator only have to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. /// Artificial ordering operator. /// /// \note This operator only has to define some strict ordering of /// the edges; this order has nothing to do with the iteration /// ordering of the edges. bool operator<(Edge) const { return false; } }; /// This iterator goes through each edge. /// This iterator goes through each edge of a graph. /// Its usage is quite simple, for example you can count the number /// of edges in a graph \c g of type \c Graph as follows: /// Iterator class for the edges. /// This iterator goes through each edge of the graph. /// Its usage is quite simple, for example, you can count the number /// of edges in a graph \c g of type \c %Graph as follows: ///\code /// int count=0; /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the iterator to an undefined value. EdgeIt() { } /// Copy constructor. /// EdgeIt(const EdgeIt& e) : Edge(e) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the iterator to be invalid. /// \sa Invalid for more details. EdgeIt(Invalid) { } /// This constructor sets the iterator to the first edge. /// This constructor sets the iterator to the first edge. EdgeIt(const Graph&) { } /// Edge -> EdgeIt conversion /// Sets the iterator to the value of the trivial iterator. /// This feature necessitates that each time we /// iterate the edge-set, the iteration order is the /// same. /// Sets the iterator to the first edge. /// Sets the iterator to the first edge of the given graph. /// explicit EdgeIt(const Graph&) { } /// Sets the iterator to the given edge. /// Sets the iterator to the given edge of the given graph. /// EdgeIt(const Graph&, const Edge&) { } /// Next edge /// Assign the iterator to the next edge. /// EdgeIt& operator++() { return *this; } }; /// \brief This iterator goes trough the incident undirected /// arcs of a node. /// /// This iterator goes trough the incident edges /// of a certain node of a graph. You should assume that the /// loop arcs will be iterated twice. /// /// Its usage is quite simple, for example you can compute the /// degree (i.e. count the number of incident arcs of a node \c n /// in graph \c g of type \c Graph as follows. /// Iterator class for the incident edges of a node. /// This iterator goes trough the incident undirected edges /// of a certain node of a graph. /// Its usage is quite simple, for example, you can compute the /// degree (i.e. the number of incident edges) of a node \c n /// in a graph \c g of type \c %Graph as follows. /// ///\code /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode /// /// \warning Loop edges will be iterated twice. class IncEdgeIt : public Edge { public: /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the iterator to an undefined value. IncEdgeIt() { } /// Copy constructor. /// IncEdgeIt(const IncEdgeIt& e) : Edge(e) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the iterator to be invalid. /// \sa Invalid for more details. IncEdgeIt(Invalid) { } /// This constructor sets the iterator to first incident arc. /// This constructor set the iterator to the first incident arc of /// the node. /// Sets the iterator to the first incident edge. /// Sets the iterator to the first incident edge of the given node. /// IncEdgeIt(const Graph&, const Node&) { } /// Edge -> IncEdgeIt conversion /// Sets the iterator to the value of the trivial iterator \c e. /// This feature necessitates that each time we /// iterate the arc-set, the iteration order is the same. /// Sets the iterator to the given edge. /// Sets the iterator to the given edge of the given graph. /// IncEdgeIt(const Graph&, const Edge&) { } /// Next incident arc /// Assign the iterator to the next incident arc /// Next incident edge /// Assign the iterator to the next incident edge /// of the corresponding node. IncEdgeIt& operator++() { return *this; } }; /// The directed arc type. /// The directed arc type. It can be converted to the /// edge or it should be inherited from the undirected /// edge. /// The arc type of the graph /// This class identifies a directed arc of the graph. It also serves /// as a base class of the arc iterators, /// thus they will convert to this type. class Arc { public: /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the object to an undefined value. Arc() { } /// Copy constructor. /// Arc(const Arc&) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the object to be invalid. /// \sa Invalid for more details. Arc(Invalid) { } /// Equality operator /// Equality operator. /// /// Two iterators are equal if and only if they point to the /// same object or both are invalid. /// same object or both are \c INVALID. bool operator==(Arc) const { return true; } /// Inequality operator /// \sa operator==(Arc n) /// /// Inequality operator. bool operator!=(Arc) const { return true; } /// Artificial ordering operator. /// To allow the use of graph descriptors as key type in std::map or /// similar associative container we require this. /// /// \note This operator only have to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. /// Artificial ordering operator. /// /// \note This operator only has to define some strict ordering of /// the arcs; this order has nothing to do with the iteration /// ordering of the arcs. bool operator<(Arc) const { return false; } /// Converison to Edge /// Converison to \c Edge /// Converison to \c Edge. /// operator Edge() const { return Edge(); } }; /// This iterator goes through each directed arc. /// This iterator goes through each arc of a graph. /// Its usage is quite simple, for example you can count the number /// of arcs in a graph \c g of type \c Graph as follows: /// Iterator class for the arcs. /// This iterator goes through each directed arc of the graph. /// Its usage is quite simple, for example, you can count the number /// of arcs in a graph \c g of type \c %Graph as follows: ///\code /// int count=0; /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count; /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count; ///\endcode class ArcIt : public Arc { /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the iterator to an undefined value. ArcIt() { } /// Copy constructor. /// ArcIt(const ArcIt& e) : Arc(e) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the iterator to be invalid. /// \sa Invalid for more details. ArcIt(Invalid) { } /// This constructor sets the iterator to the first arc. /// This constructor sets the iterator to the first arc of \c g. ///@param g the graph ArcIt(const Graph &g) { ::lemon::ignore_unused_variable_warning(g); } /// Arc -> ArcIt conversion /// Sets the iterator to the value of the trivial iterator \c e. /// This feature necessitates that each time we /// iterate the arc-set, the iteration order is the same. /// Sets the iterator to the first arc. /// Sets the iterator to the first arc of the given graph. /// explicit ArcIt(const Graph &g) { ::lemon::ignore_unused_variable_warning(g); } /// Sets the iterator to the given arc. /// Sets the iterator to the given arc of the given graph. /// ArcIt(const Graph&, const Arc&) { } ///Next arc /// Next arc /// Assign the iterator to the next arc. /// ArcIt& operator++() { return *this; } }; /// This iterator goes trough the outgoing directed arcs of a node. /// This iterator goes trough the \e outgoing arcs of a certain node /// of a graph. /// Its usage is quite simple, for example you can count the number /// Iterator class for the outgoing arcs of a node. /// This iterator goes trough the \e outgoing directed arcs of a /// certain node of a graph. /// Its usage is quite simple, for example, you can count the number /// of outgoing arcs of a node \c n /// in graph \c g of type \c Graph as follows. /// in a graph \c g of type \c %Graph as follows. ///\code /// int count=0; /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count; /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; ///\endcode class OutArcIt : public Arc { public: /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the iterator to an undefined value. OutArcIt() { } /// Copy constructor. /// OutArcIt(const OutArcIt& e) : Arc(e) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the iterator to be invalid. /// \sa Invalid for more details. OutArcIt(Invalid) { } /// This constructor sets the iterator to the first outgoing arc. /// This constructor sets the iterator to the first outgoing arc of /// the node. ///@param n the node ///@param g the graph /// Sets the iterator to the first outgoing arc. /// Sets the iterator to the first outgoing arc of the given node. /// OutArcIt(const Graph& n, const Node& g) { ::lemon::ignore_unused_variable_warning(n); ::lemon::ignore_unused_variable_warning(g); } /// Arc -> OutArcIt conversion /// Sets the iterator to the value of the trivial iterator. /// This feature necessitates that each time we /// iterate the arc-set, the iteration order is the same. /// Sets the iterator to the given arc. /// Sets the iterator to the given arc of the given graph. /// OutArcIt(const Graph&, const Arc&) { } ///Next outgoing arc /// Next outgoing arc /// Assign the iterator to the next }; /// This iterator goes trough the incoming directed arcs of a node. /// This iterator goes trough the \e incoming arcs of a certain node /// of a graph. /// Its usage is quite simple, for example you can count the number /// of outgoing arcs of a node \c n /// in graph \c g of type \c Graph as follows. /// Iterator class for the incoming arcs of a node. /// This iterator goes trough the \e incoming directed arcs of a /// certain node of a graph. /// Its usage is quite simple, for example, you can count the number /// of incoming arcs of a node \c n /// in a graph \c g of type \c %Graph as follows. ///\code /// int count=0; /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count; /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; ///\endcode class InArcIt : public Arc { public: /// Default constructor /// @warning The default constructor sets the iterator /// to an undefined value. /// Default constructor. /// \warning It sets the iterator to an undefined value. InArcIt() { } /// Copy constructor. /// InArcIt(const InArcIt& e) : Arc(e) { } /// Initialize the iterator to be invalid. /// Initialize the iterator to be invalid. /// /// %Invalid constructor \& conversion. /// Initializes the iterator to be invalid. /// \sa Invalid for more details. InArcIt(Invalid) { } /// This constructor sets the iterator to first incoming arc. /// This constructor set the iterator to the first incoming arc of /// the node. ///@param n the node ///@param g the graph /// Sets the iterator to the first incoming arc. /// Sets the iterator to the first incoming arc of the given node. /// InArcIt(const Graph& g, const Node& n) { ::lemon::ignore_unused_variable_warning(n); ::lemon::ignore_unused_variable_warning(g); } /// Arc -> InArcIt conversion /// Sets the iterator to the value of the trivial iterator \c e. /// This feature necessitates that each time we /// iterate the arc-set, the iteration order is the same. /// Sets the iterator to the given arc. /// Sets the iterator to the given arc of the given graph. /// InArcIt(const Graph&, const Arc&) { } /// Next incoming arc /// Assign the iterator to the next inarc of the corresponding node. /// /// Assign the iterator to the next /// incoming arc of the corresponding node. InArcIt& operator++() { return *this; } }; /// \brief Reference map of the nodes to type \c T. /// /// Reference map of the nodes to type \c T. /// \brief Standard graph map type for the nodes. /// /// Standard graph map type for the nodes. /// It conforms to the ReferenceMap concept. template class NodeMap : public ReferenceMap public: ///\e NodeMap(const Graph&) { } ///\e /// Constructor explicit NodeMap(const Graph&) { } /// Constructor with given initial value NodeMap(const Graph&, T) { } }; /// \brief Reference map of the arcs to type \c T. /// /// Reference map of the arcs to type \c T. /// \brief Standard graph map type for the arcs. /// /// Standard graph map type for the arcs. /// It conforms to the ReferenceMap concept. template class ArcMap : public ReferenceMap public: ///\e ArcMap(const Graph&) { } ///\e /// Constructor explicit ArcMap(const Graph&) { } /// Constructor with given initial value ArcMap(const Graph&, T) { } private: ///Copy constructor }; /// Reference map of the edges to type \c T. /// Reference map of the edges to type \c T. /// \brief Standard graph map type for the edges. /// /// Standard graph map type for the edges. /// It conforms to the ReferenceMap concept. template class EdgeMap : public ReferenceMap public: ///\e EdgeMap(const Graph&) { } ///\e /// Constructor explicit EdgeMap(const Graph&) { } /// Constructor with given initial value EdgeMap(const Graph&, T) { } private: ///Copy constructor }; /// \brief Direct the given edge. /// /// Direct the given edge. The returned arc source /// will be the given node. Arc direct(const Edge&, const Node&) const { return INVALID; } /// \brief Direct the given edge. /// /// Direct the given edge. The returned arc /// represents the given edge and the direction comes /// from the bool parameter. The source of the edge and /// the directed arc is the same when the given bool is true. Arc direct(const Edge&, bool) const { return INVALID; } /// \brief Returns true if the arc has default orientation. /// /// Returns whether the given directed arc is same orientation as /// the corresponding edge's default orientation. bool direction(Arc) const { return true; } /// \brief Returns the opposite directed arc. /// /// Returns the opposite directed arc. Arc oppositeArc(Arc) const { return INVALID; } /// \brief Opposite node on an arc /// /// \return The opposite of the given node on the given edge. Node oppositeNode(Node, Edge) const { return INVALID; } /// \brief First node of the edge. /// /// \return The first node of the given edge. /// /// Naturally edges don't have direction and thus /// don't have source and target node. However we use \c u() and \c v() /// methods to query the two nodes of the arc. The direction of the /// arc which arises this way is called the inherent direction of the /// edge, and is used to define the "default" direction /// of the directed versions of the arcs. /// \brief The first node of the edge. /// /// Returns the first node of the given edge. /// /// Edges don't have source and target nodes, however, methods /// u() and v() are used to query the two end-nodes of an edge. /// The orientation of an edge that arises this way is called /// the inherent direction, it is used to define the default /// direction for the corresponding arcs. /// \sa v() /// \sa direction() Node u(Edge) const { return INVALID; } /// \brief Second node of the edge. /// /// \return The second node of the given edge. /// /// Naturally edges don't have direction and thus /// don't have source and target node. However we use \c u() and \c v() /// methods to query the two nodes of the arc. The direction of the /// arc which arises this way is called the inherent direction of the /// edge, and is used to define the "default" direction /// of the directed versions of the arcs. /// \brief The second node of the edge. /// /// Returns the second node of the given edge. /// /// Edges don't have source and target nodes, however, methods /// u() and v() are used to query the two end-nodes of an edge. /// The orientation of an edge that arises this way is called /// the inherent direction, it is used to define the default /// direction for the corresponding arcs. /// \sa u() /// \sa direction() Node v(Edge) const { return INVALID; } /// \brief Source node of the directed arc. /// \brief The source node of the arc. /// /// Returns the source node of the given arc. Node source(Arc) const { return INVALID; } /// \brief Target node of the directed arc. /// \brief The target node of the arc. /// /// Returns the target node of the given arc. Node target(Arc) const { return INVALID; } /// \brief Returns the id of the node. /// \brief The ID of the node. /// /// Returns the ID of the given node. int id(Node) const { return -1; } /// \brief Returns the id of the edge. /// \brief The ID of the edge. /// /// Returns the ID of the given edge. int id(Edge) const { return -1; } /// \brief Returns the id of the arc. /// \brief The ID of the arc. /// /// Returns the ID of the given arc. int id(Arc) const { return -1; } /// \brief Returns the node with the given id. /// /// \pre The argument should be a valid node id in the graph. /// \brief The node with the given ID. /// /// Returns the node with the given ID. /// \pre The argument should be a valid node ID in the graph. Node nodeFromId(int) const { return INVALID; } /// \brief Returns the edge with the given id. /// /// \pre The argument should be a valid edge id in the graph. /// \brief The edge with the given ID. /// /// Returns the edge with the given ID. /// \pre The argument should be a valid edge ID in the graph. Edge edgeFromId(int) const { return INVALID; } /// \brief Returns the arc with the given id. /// /// \pre The argument should be a valid arc id in the graph. /// \brief The arc with the given ID. /// /// Returns the arc with the given ID. /// \pre The argument should be a valid arc ID in the graph. Arc arcFromId(int) const { return INVALID; } /// \brief Returns an upper bound on the node IDs. /// \brief An upper bound on the node IDs. /// /// Returns an upper bound on the node IDs. int maxNodeId() const { return -1; } /// \brief Returns an upper bound on the edge IDs. /// \brief An upper bound on the edge IDs. /// /// Returns an upper bound on the edge IDs. int maxEdgeId() const { return -1; } /// \brief Returns an upper bound on the arc IDs. /// \brief An upper bound on the arc IDs. /// /// Returns an upper bound on the arc IDs. int maxArcId() const { return -1; } /// \brief The direction of the arc. /// /// Returns \c true if the direction of the given arc is the same as /// the inherent orientation of the represented edge. bool direction(Arc) const { return true; } /// \brief Direct the edge. /// /// Direct the given edge. The returned arc /// represents the given edge and its direction comes /// from the bool parameter. If it is \c true, then the direction /// of the arc is the same as the inherent orientation of the edge. Arc direct(Edge, bool) const { return INVALID; } /// \brief Direct the edge. /// /// Direct the given edge. The returned arc represents the given /// edge and its source node is the given node. Arc direct(Edge, Node) const { return INVALID; } /// \brief The oppositely directed arc. /// /// Returns the oppositely directed arc representing the same edge. Arc oppositeArc(Arc) const { return INVALID; } /// \brief The opposite node on the edge. /// /// Returns the opposite node on the given edge. Node oppositeNode(Node, Edge) const { return INVALID; } void first(Node&) const {} int maxId(Arc) const { return -1; } /// \brief Base node of the iterator /// /// Returns the base node (the source in this case) of the iterator Node baseNode(OutArcIt e) const { return source(e); } /// \brief Running node of the iterator /// /// Returns the running node (the target in this case) of the /// iterator Node runningNode(OutArcIt e) const { return target(e); } /// \brief Base node of the iterator /// /// Returns the base node (the target in this case) of the iterator Node baseNode(InArcIt e) const { return target(e); } /// \brief Running node of the iterator /// /// Returns the running node (the source in this case) of the /// iterator Node runningNode(InArcIt e) const { return source(e); } /// \brief Base node of the iterator /// /// Returns the base node of the iterator Node baseNode(IncEdgeIt) const { return INVALID; } /// \brief Running node of the iterator /// /// Returns the running node of the iterator Node runningNode(IncEdgeIt) const { return INVALID; } /// \brief The base node of the iterator. /// /// Returns the base node of the given incident edge iterator. Node baseNode(IncEdgeIt) const { return INVALID; } /// \brief The running node of the iterator. /// /// Returns the running node of the given incident edge iterator. Node runningNode(IncEdgeIt) const { return INVALID; } /// \brief The base node of the iterator. /// /// Returns the base node of the given outgoing arc iterator /// (i.e. the source node of the corresponding arc). Node baseNode(OutArcIt) const { return INVALID; } /// \brief The running node of the iterator. /// /// Returns the running node of the given outgoing arc iterator /// (i.e. the target node of the corresponding arc). Node runningNode(OutArcIt) const { return INVALID; } /// \brief The base node of the iterator. /// /// Returns the base node of the given incomming arc iterator /// (i.e. the target node of the corresponding arc). Node baseNode(InArcIt) const { return INVALID; } /// \brief The running node of the iterator. /// /// Returns the running node of the given incomming arc iterator /// (i.e. the source node of the corresponding arc). Node runningNode(InArcIt) const { return INVALID; } template
• ## lemon/concepts/graph_components.h

 r1173 bool b; ignore_unused_variable_warning(b); ::lemon::ignore_unused_variable_warning(b); b = (ia == ib) && (ia != ib); ue = e; bool d = graph.direction(e); ignore_unused_variable_warning(d); ::lemon::ignore_unused_variable_warning(d); } } nid = digraph.maxNodeId(); ignore_unused_variable_warning(nid); ::lemon::ignore_unused_variable_warning(nid); eid = digraph.maxArcId(); ignore_unused_variable_warning(eid); ::lemon::ignore_unused_variable_warning(eid); } edge = graph.edgeFromId(ueid); ueid = graph.maxEdgeId(); ignore_unused_variable_warning(ueid); ::lemon::ignore_unused_variable_warning(ueid); } _GraphItemIt it3 = it1; _GraphItemIt it4 = INVALID; ignore_unused_variable_warning(it3); ignore_unused_variable_warning(it4); ::lemon::ignore_unused_variable_warning(it3); ::lemon::ignore_unused_variable_warning(it4); it2 = ++it1; _GraphIncIt it3 = it1; _GraphIncIt it4 = INVALID; ignore_unused_variable_warning(it3); ignore_unused_variable_warning(it4); ::lemon::ignore_unused_variable_warning(it3); ::lemon::ignore_unused_variable_warning(it4); it2 = ++it1; n = digraph.baseNode(oait); n = digraph.runningNode(oait); ignore_unused_variable_warning(n); ::lemon::ignore_unused_variable_warning(n); } } = digraph.notifier(typename _Digraph::Arc()); ignore_unused_variable_warning(nn); ignore_unused_variable_warning(en); ::lemon::ignore_unused_variable_warning(nn); ::lemon::ignore_unused_variable_warning(en); } typename _Graph::EdgeNotifier& uen = graph.notifier(typename _Graph::Edge()); ignore_unused_variable_warning(uen); ::lemon::ignore_unused_variable_warning(uen); } // m3 = cmap; ignore_unused_variable_warning(m1); ignore_unused_variable_warning(m2); // ignore_unused_variable_warning(m3); ::lemon::ignore_unused_variable_warning(m1); ::lemon::ignore_unused_variable_warning(m2); // ::lemon::ignore_unused_variable_warning(m3); }
• ## lemon/concepts/graph_components.h

 r1257 * This file is a part of LEMON, a generic C++ optimization library. * * Copyright (C) 2003-2009 * Copyright (C) 2003-2010 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). ///\ingroup graph_concepts ///\file ///\brief The concept of graph components. ///\brief The concepts of graph components. #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H /// \note This class is a template class so that we can use it to /// create graph skeleton classes. The reason for this is that \c Node /// and \c Arc (or \c Edge) types should \e not derive from the same /// and \c Arc (or \c Edge) types should \e not derive from the same /// base class. For \c Node you should instantiate it with character /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'. /// /// This operator defines an ordering of the items. /// It makes possible to use graph item types as key types in /// It makes possible to use graph item types as key types in /// associative containers (e.g. \c std::map). /// /// \note This operator only have to define some strict ordering of /// \note This operator only has to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. /// This class describes the base interface of directed graph types. /// All digraph %concepts have to conform to this class. /// It just provides types for nodes and arcs and functions /// It just provides types for nodes and arcs and functions /// to get the source and the target nodes of arcs. class BaseDigraphComponent { /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types. /// /// This class describes the concept of \c NodeIt, \c ArcIt and /// This class describes the concept of \c NodeIt, \c ArcIt and /// \c EdgeIt subtypes of digraph and graph types. template /// next item. GraphItemIt& operator++() { return *this; } /// \brief Equality operator /// }; /// \brief Concept class for \c InArcIt, \c OutArcIt and /// \brief Concept class for \c InArcIt, \c OutArcIt and /// \c IncEdgeIt types. /// /// This class describes the concept of \c InArcIt, \c OutArcIt /// This class describes the concept of \c InArcIt, \c OutArcIt /// and \c IncEdgeIt subtypes of digraph and graph types. /// /// \note Since these iterator classes do not inherit from the same /// base class, there is an additional template parameter (selector) /// \c sel. For \c InArcIt you should instantiate it with character /// \c sel. For \c InArcIt you should instantiate it with character /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'. template
• ## lemon/concepts/heap.h

 r1127 item=Item(); prio=Prio(); ignore_unused_variable_warning(item); ignore_unused_variable_warning(prio); ::lemon::ignore_unused_variable_warning(item); ::lemon::ignore_unused_variable_warning(prio); OwnItem own_item; own_item=Item(); own_prio=Prio(); ignore_unused_variable_warning(own_item); ignore_unused_variable_warning(own_prio); ignore_unused_variable_warning(own_state); ::lemon::ignore_unused_variable_warning(own_item); ::lemon::ignore_unused_variable_warning(own_prio); ::lemon::ignore_unused_variable_warning(own_state); _Heap heap1(map); _Heap heap2 = heap1; ignore_unused_variable_warning(heap1); ignore_unused_variable_warning(heap2); ::lemon::ignore_unused_variable_warning(heap1); ::lemon::ignore_unused_variable_warning(heap2); int s = heap.size(); ignore_unused_variable_warning(s); ::lemon::ignore_unused_variable_warning(s); bool e = heap.empty(); ignore_unused_variable_warning(e); ::lemon::ignore_unused_variable_warning(e); prio = heap.prio();

• ## lemon/concepts/path.h

 r1127 template Path& operator=(const CPath& cpath) { ignore_unused_variable_warning(cpath); ::lemon::ignore_unused_variable_warning(cpath); return *this; } e = (i < ii); ignore_unused_variable_warning(l); ignore_unused_variable_warning(pp); ignore_unused_variable_warning(e); ignore_unused_variable_warning(id); ignore_unused_variable_warning(ii); ignore_unused_variable_warning(ed); ::lemon::ignore_unused_variable_warning(l); ::lemon::ignore_unused_variable_warning(pp); ::lemon::ignore_unused_variable_warning(e); ::lemon::ignore_unused_variable_warning(id); ::lemon::ignore_unused_variable_warning(ii); ::lemon::ignore_unused_variable_warning(ed); } }; e = (i != INVALID); ignore_unused_variable_warning(l); ignore_unused_variable_warning(e); ignore_unused_variable_warning(id); ignore_unused_variable_warning(ed); ::lemon::ignore_unused_variable_warning(l); ::lemon::ignore_unused_variable_warning(e); ::lemon::ignore_unused_variable_warning(id); ::lemon::ignore_unused_variable_warning(ed); } _Path& p; e = (i != INVALID); ignore_unused_variable_warning(l); ignore_unused_variable_warning(e); ignore_unused_variable_warning(id); ignore_unused_variable_warning(ed); ::lemon::ignore_unused_variable_warning(l); ::lemon::ignore_unused_variable_warning(e); ::lemon::ignore_unused_variable_warning(id); ::lemon::ignore_unused_variable_warning(ed); } _Path& p;
• ## lemon/concepts/path.h

 r1257 ///\ingroup concept ///\file ///\brief Classes for representing paths in digraphs. ///\brief The concept of paths /// /// A skeleton structure for representing directed paths in a /// digraph. /// In a sense, a path can be treated as a list of arcs. /// LEMON path types just store this list. As a consequence, they cannot /// enumerate the nodes on the path directly and a zero length path /// cannot store its source node. /// /// The arcs of a path should be stored in the order of their directions, /// i.e. the target node of each arc should be the same as the source /// node of the next arc. This consistency could be checked using /// \ref checkPath(). /// The source and target nodes of a (consistent) path can be obtained /// using \ref pathSource() and \ref pathTarget(). /// /// A path can be constructed from another path of any type using the /// copy constructor or the assignment operator. /// /// \tparam GR The digraph type in which the path is. /// /// In a sense, the path can be treated as a list of arcs. The /// lemon path type stores just this list. As a consequence it /// cannot enumerate the nodes in the path and the zero length /// paths cannot store the source. /// template class Path { Path() {} /// \brief Template constructor /// \brief Template copy constructor template Path(const CPath& cpath) {} /// \brief Template assigment /// \brief Template assigment operator template Path& operator=(const CPath& cpath) { } /// Length of the path ie. the number of arcs in the path. /// Length of the path, i.e. the number of arcs on the path. int length() const { return 0;} void clear() {} /// \brief LEMON style iterator for path arcs /// \brief LEMON style iterator for enumerating the arcs of a path. /// /// This class is used to iterate on the arcs of the paths. /// LEMON style iterator class for enumerating the arcs of a path. class ArcIt { public: /// Invalid constructor ArcIt(Invalid) {} /// Constructor for first arc /// Sets the iterator to the first arc of the given path ArcIt(const Path &) {} /// Conversion to Arc /// Conversion to \c Arc operator Arc() const { return INVALID; } /// /// A skeleton structure for path dumpers. The path dumpers are /// the generalization of the paths. The path dumpers can /// enumerate the arcs of the path wheter in forward or in /// backward order.  In most time these classes are not used /// directly rather it used to assign a dumped class to a real /// path type. /// the generalization of the paths, they can enumerate the arcs /// of the path either in forward or in backward order. /// These classes are typically not used directly, they are rather /// used to be assigned to a real path type. /// /// The main purpose of this concept is that the shortest path /// algorithms can enumerate easily the arcs in reverse order. /// If we would like to give back a real path from these /// algorithms then we should create a temporarly path object. In /// LEMON such algorithms gives back a path dumper what can /// assigned to a real path and the dumpers can be implemented as /// algorithms can enumerate the arcs easily in reverse order. /// In LEMON, such algorithms give back a (reverse) path dumper that /// can be assigned to a real path. The dumpers can be implemented as /// an adaptor class to the predecessor map. /// /// \tparam GR The digraph type in which the path is. /// /// The paths can be constructed from any path type by a /// template constructor or a template assignment operator. template class PathDumper { typedef typename Digraph::Arc Arc; /// Length of the path ie. the number of arcs in the path. /// Length of the path, i.e. the number of arcs on the path. int length() const { return 0;} /// \brief Forward or reverse dumping /// /// If the RevPathTag is defined and true then reverse dumping /// is provided in the path dumper. In this case instead of the /// ArcIt the RevArcIt iterator should be implemented in the /// dumper. /// If this tag is defined to be \c True, then reverse dumping /// is provided in the path dumper. In this case, \c RevArcIt /// iterator should be implemented instead of \c ArcIt iterator. typedef False RevPathTag; /// \brief LEMON style iterator for path arcs /// \brief LEMON style iterator for enumerating the arcs of a path. /// /// This class is used to iterate on the arcs of the paths. /// LEMON style iterator class for enumerating the arcs of a path. class ArcIt { public: /// Invalid constructor ArcIt(Invalid) {} /// Constructor for first arc /// Sets the iterator to the first arc of the given path ArcIt(const PathDumper&) {} /// Conversion to Arc /// Conversion to \c Arc operator Arc() const { return INVALID; } }; /// \brief LEMON style iterator for path arcs /// \brief LEMON style iterator for enumerating the arcs of a path /// in reverse direction. /// /// This class is used to iterate on the arcs of the paths in /// reverse direction. /// LEMON style iterator class for enumerating the arcs of a path /// in reverse direction. class RevArcIt { public: /// Invalid constructor RevArcIt(Invalid) {} /// Constructor for first arc /// Sets the iterator to the last arc of the given path RevArcIt(const PathDumper &) {} /// Conversion to Arc /// Conversion to \c Arc operator Arc() const { return INVALID; }
• ## lemon/core.h

 r1159 #ifdef _MSC_VER #pragma warning( disable : 4250 4355 4503 4800 4996 ) #endif #ifdef __GNUC__ #define GCC_VERSION (__GNUC__ * 10000                   \ + __GNUC_MINOR__ * 100             \ + __GNUC_PATCHLEVEL__) #endif #if GCC_VERSION >= 40800 // Needed by the [DI]GRAPH_TYPEDEFS marcos for gcc 4.8 #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif
• ## lemon/core.h

 r1246 * This file is a part of LEMON, a generic C++ optimization library. * * Copyright (C) 2003-2009 * Copyright (C) 2003-2010 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). protected: class AutoNodeMap : public ItemSetTraits::template Map::Type { class AutoNodeMap : public ItemSetTraits::template Map::Type { typedef typename ItemSetTraits::template Map::Type Parent; }; protected: protected: const Digraph &_g;
• ## lemon/cplex.cc

 r1142 int status; _cnt = new int; (*_cnt) = 1; _env = CPXopenCPLEX(&status); if (_env == 0) {
• ## lemon/cplex.cc

 r1181 * This file is a part of LEMON, a generic C++ optimization library. * * Copyright (C) 2003-2009 * Copyright (C) 2003-2010 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). } int CplexBase::_addRow(Value lb, ExprIterator b, ExprIterator e, Value ub) { int i = CPXgetnumrows(cplexEnv(), _prob); if (lb == -INF) { const char s = 'L'; CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0); } else if (ub == INF) { const char s = 'G'; CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0); } else if (lb == ub){ const char s = 'E'; CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0); } else { const char s = 'R'; double len = ub - lb; CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0); } std::vector indices; std::vector rowlist; std::vector values; for(ExprIterator it=b; it!=e; ++it) { indices.push_back(it->first); values.push_back(it->second); rowlist.push_back(i); } CPXchgcoeflist(cplexEnv(), _prob, values.size(), &rowlist.front(), &indices.front(), &values.front()); return i; } void CplexBase::_eraseCol(int i) { void CplexBase::_applyMessageLevel() { CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, _message_enabled ? CPX_ON : CPX_OFF); }
• ## lemon/graph_to_eps.h

 r1159 using T::_copyright; using typename T::NodeTextColorType; using T::NodeTextColorType; using T::CUST_COL; using T::DIST_COL;
• ## lemon/graph_to_eps.h

 r1247 * This file is a part of LEMON, a generic C++ optimization library. * * Copyright (C) 2003-2009 * Copyright (C) 2003-2010 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). ///\param gr  Reference to the graph to be printed. ///\param ost Reference to the output stream. ///By default it is std::cout. ///By default, it is std::cout. ///\param pros If it is \c true, then the \c ostream referenced by \c os ///will be explicitly deallocated by the destructor. ///Turn on/off pre-scaling ///By default graphToEps() rescales the whole image in order to avoid ///By default, graphToEps() rescales the whole image in order to avoid ///very big or very small bounding boxes. /// ///\param g Reference to the graph to be printed. ///\param os Reference to the output stream. ///By default it is std::cout. ///By default, it is std::cout. /// ///This function also has a lot of ///\endcode /// ///For more detailed examples see the \ref graph_to_eps_demo.cc demo file. ///For more detailed examples, see the \ref graph_to_eps_demo.cc demo file. /// ///\warning Don't forget to put the \ref GraphToEps::run() "run()"
Note: See TracChangeset for help on using the changeset viewer.