COIN-OR::LEMON - Graph Library

Ignore:
Timestamp:
01/11/12 22:21:07 (8 years ago)
Author:
Balazs Dezso <deba@…>
Branch:
default
Phase:
public
Message:

Renamings in BpGraphs? (#69)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/concepts/graph_components.h

    r1193 r1194  
    12071207      ///
    12081208      /// This iterator goes through each red node.
    1209       typedef GraphItemIt<BpGraph, RedNode> RedIt;
     1209      typedef GraphItemIt<BpGraph, RedNode> RedNodeIt;
    12101210
    12111211      /// \brief This iterator goes through each blue node.
    12121212      ///
    12131213      /// This iterator goes through each blue node.
    1214       typedef GraphItemIt<BpGraph, BlueNode> BlueIt;
     1214      typedef GraphItemIt<BpGraph, BlueNode> BlueNodeIt;
    12151215
    12161216      /// @}
     
    12291229
    12301230          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::RedNode>,
    1231             typename _BpGraph::RedIt>();
     1231            typename _BpGraph::RedNodeIt>();
    12321232          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::BlueNode>,
    1233             typename _BpGraph::BlueIt>();
     1233            typename _BpGraph::BlueNodeIt>();
    12341234        }
    12351235
     
    17161716    /// bipartite graphs.  It extends \ref MappableGraphComponent with
    17171717    /// the standard graph map class for red and blue nodes (\c
    1718     /// RedMap and BlueMap). This concept is part of the BpGraph concept.
     1718    /// RedNodeMap and BlueNodeMap). This concept is part of the
     1719    /// BpGraph concept.
    17191720    template <typename BAS = BaseBpGraphComponent>
    17201721    class MappableBpGraphComponent : public MappableGraphComponent<BAS>  {
     
    17311732      /// It conforms to the ReferenceMap concept.
    17321733      template <typename V>
    1733       class RedMap : public GraphMap<MappableBpGraphComponent, Node, V> {
     1734      class RedNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
    17341735        typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
    17351736
     
    17381739        ///
    17391740        /// Construct a new map for the graph.
    1740         explicit RedMap(const MappableBpGraphComponent& graph)
     1741        explicit RedNodeMap(const MappableBpGraphComponent& graph)
    17411742          : Parent(graph) {}
    17421743
     
    17441745        ///
    17451746        /// Construct a new map for the graph and initalize the values.
    1746         RedMap(const MappableBpGraphComponent& graph, const V& value)
     1747        RedNodeMap(const MappableBpGraphComponent& graph, const V& value)
    17471748          : Parent(graph, value) {}
    17481749
     
    17511752        ///
    17521753        /// Copy Constructor.
    1753         RedMap(const RedMap& nm) : Parent(nm) {}
     1754        RedNodeMap(const RedNodeMap& nm) : Parent(nm) {}
    17541755
    17551756        /// \brief Assignment operator.
     
    17571758        /// Assignment operator.
    17581759        template <typename CMap>
    1759         RedMap& operator=(const CMap&) {
     1760        RedNodeMap& operator=(const CMap&) {
    17601761          checkConcept<ReadMap<Node, V>, CMap>();
    17611762          return *this;
     
    17691770      /// It conforms to the ReferenceMap concept.
    17701771      template <typename V>
    1771       class BlueMap : public GraphMap<MappableBpGraphComponent, Node, V> {
     1772      class BlueNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
    17721773        typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
    17731774
     
    17761777        ///
    17771778        /// Construct a new map for the graph.
    1778         explicit BlueMap(const MappableBpGraphComponent& graph)
     1779        explicit BlueNodeMap(const MappableBpGraphComponent& graph)
    17791780          : Parent(graph) {}
    17801781
     
    17821783        ///
    17831784        /// Construct a new map for the graph and initalize the values.
    1784         BlueMap(const MappableBpGraphComponent& graph, const V& value)
     1785        BlueNodeMap(const MappableBpGraphComponent& graph, const V& value)
    17851786          : Parent(graph, value) {}
    17861787
     
    17891790        ///
    17901791        /// Copy Constructor.
    1791         BlueMap(const BlueMap& nm) : Parent(nm) {}
     1792        BlueNodeMap(const BlueNodeMap& nm) : Parent(nm) {}
    17921793
    17931794        /// \brief Assignment operator.
     
    17951796        /// Assignment operator.
    17961797        template <typename CMap>
    1797         BlueMap& operator=(const CMap&) {
     1798        BlueNodeMap& operator=(const CMap&) {
    17981799          checkConcept<ReadMap<Node, V>, CMap>();
    17991800          return *this;
     
    18161817
    18171818          { // int map test
    1818             typedef typename _BpGraph::template RedMap<int> IntRedMap;
     1819            typedef typename _BpGraph::template RedNodeMap<int>
     1820              IntRedNodeMap;
    18191821            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, int>,
    1820               IntRedMap >();
     1822              IntRedNodeMap >();
    18211823          } { // bool map test
    1822             typedef typename _BpGraph::template RedMap<bool> BoolRedMap;
     1824            typedef typename _BpGraph::template RedNodeMap<bool>
     1825              BoolRedNodeMap;
    18231826            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, bool>,
    1824               BoolRedMap >();
     1827              BoolRedNodeMap >();
    18251828          } { // Dummy map test
    1826             typedef typename _BpGraph::template RedMap<Dummy> DummyRedMap;
     1829            typedef typename _BpGraph::template RedNodeMap<Dummy>
     1830              DummyRedNodeMap;
    18271831            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, Dummy>,
    1828               DummyRedMap >();
     1832              DummyRedNodeMap >();
    18291833          }
    18301834
    18311835          { // int map test
    1832             typedef typename _BpGraph::template BlueMap<int> IntBlueMap;
     1836            typedef typename _BpGraph::template BlueNodeMap<int>
     1837              IntBlueNodeMap;
    18331838            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, int>,
    1834               IntBlueMap >();
     1839              IntBlueNodeMap >();
    18351840          } { // bool map test
    1836             typedef typename _BpGraph::template BlueMap<bool> BoolBlueMap;
     1841            typedef typename _BpGraph::template BlueNodeMap<bool>
     1842              BoolBlueNodeMap;
    18371843            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, bool>,
    1838               BoolBlueMap >();
     1844              BoolBlueNodeMap >();
    18391845          } { // Dummy map test
    1840             typedef typename _BpGraph::template BlueMap<Dummy> DummyBlueMap;
     1846            typedef typename _BpGraph::template BlueNodeMap<Dummy>
     1847              DummyBlueNodeMap;
    18411848            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, Dummy>,
    1842               DummyBlueMap >();
     1849              DummyBlueNodeMap >();
    18431850          }
    18441851        }
Note: See TracChangeset for help on using the changeset viewer.