COIN-OR::LEMON - Graph Library

Changeset 1536:308150155bb5 in lemon-0.x for lemon


Ignore:
Timestamp:
07/04/05 18:27:54 (15 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2028
Message:

Kill several doxygen warnings

Location:
lemon
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • lemon/bfs.h

    r1516 r1536  
    8585 
    8686    ///This function instantiates a \ref ProcessedMap.
    87     ///\param G is the graph, to which
     87    ///\param g is the graph, to which
    8888    ///we would like to define the \ref ProcessedMap
     89#ifdef DOXYGEN
     90    static ProcessedMap *createProcessedMap(const GR &g)
     91#else
    8992    static ProcessedMap *createProcessedMap(const GR &)
     93#endif
    9094    {
    9195      return new ProcessedMap();
     
    660664   
    661665    ///This function copies the shortest path to \c t into \c p.
    662     ///If it \c \t is a source itself or unreachable, then it does not
     666    ///If \c t is a source itself or unreachable, then it does not
    663667    ///alter \c p.
    664668    ///\todo Is it the right way to handle unreachable nodes?
     
    771775 
    772776    ///This function instantiates a \ref PredMap.
    773     ///\param G is the graph, to which we would like to define the PredMap.
     777    ///\param g is the graph, to which we would like to define the PredMap.
    774778    ///\todo The graph alone may be insufficient to initialize
     779#ifdef DOXYGEN
     780    static PredMap *createPredMap(const GR &g)
     781#else
    775782    static PredMap *createPredMap(const GR &)
     783#endif
    776784    {
    777785      return new PredMap();
     
    804812 
    805813    ///This function instantiates a \ref ProcessedMap.
    806     ///\param G is the graph, to which
     814    ///\param g is the graph, to which
    807815    ///we would like to define the \ref ProcessedMap
     816#ifdef DOXYGEN
     817    static ProcessedMap *createProcessedMap(const GR &g)
     818#else
    808819    static ProcessedMap *createProcessedMap(const GR &)
     820#endif
    809821    {
    810822      return new ProcessedMap();
     
    834846 
    835847    ///This function instantiates a \ref DistMap.
    836     ///\param G is the graph, to which we would like to define the \ref DistMap
     848    ///\param g is the graph, to which we would like to define the \ref DistMap
     849#ifdef DOXYGEN
     850    static DistMap *createDistMap(const GR &g)
     851#else
    837852    static DistMap *createDistMap(const GR &)
     853#endif
    838854    {
    839855      return new DistMap();
  • lemon/dfs.h

    r1529 r1536  
    8585 
    8686    ///This function instantiates a \ref ProcessedMap.
    87     ///\param G is the graph, to which
     87    ///\param g is the graph, to which
    8888    ///we would like to define the \ref ProcessedMap
     89#ifdef DOXYGEN
     90    static ProcessedMap *createProcessedMap(const GR &g)
     91#else
    8992    static ProcessedMap *createProcessedMap(const GR &)
     93#endif
    9094    {
    9195      return new ProcessedMap();
     
    780784 
    781785    ///This function instantiates a \ref PredMap.
    782     ///\param G is the graph, to which we would like to define the PredMap.
     786    ///\param g is the graph, to which we would like to define the PredMap.
    783787    ///\todo The graph alone may be insufficient to initialize
     788#ifdef DOXYGEN
     789    static PredMap *createPredMap(const GR &g)
     790#else
    784791    static PredMap *createPredMap(const GR &)
     792#endif
    785793    {
    786794      return new PredMap();
     
    813821 
    814822    ///This function instantiates a \ref ProcessedMap.
    815     ///\param G is the graph, to which
     823    ///\param g is the graph, to which
    816824    ///we would like to define the \ref ProcessedMap
     825#ifdef DOXYGEN
     826    static ProcessedMap *createProcessedMap(const GR &g)
     827#else
    817828    static ProcessedMap *createProcessedMap(const GR &)
     829#endif
    818830    {
    819831      return new ProcessedMap();
     
    843855 
    844856    ///This function instantiates a \ref DistMap.
    845     ///\param G is the graph, to which we would like to define the \ref DistMap
     857    ///\param g is the graph, to which we would like to define the \ref DistMap
     858#ifdef DOXYGEN
     859    static DistMap *createDistMap(const GR &g)
     860#else
    846861    static DistMap *createDistMap(const GR &)
     862#endif
    847863    {
    848864      return new DistMap();
  • lemon/dijkstra.h

    r1516 r1536  
    109109 
    110110    ///This function instantiates a \ref ProcessedMap.
    111     ///\param G is the graph, to which
     111    ///\param g is the graph, to which
    112112    ///we would like to define the \ref ProcessedMap
     113#ifdef DOXYGEN
     114    static ProcessedMap *createProcessedMap(const GR &g)
     115#else
    113116    static ProcessedMap *createProcessedMap(const GR &)
     117#endif
    114118    {
    115119      return new ProcessedMap();
     
    664668   
    665669    ///This function copies the shortest path to \c t into \c p.
    666     ///If it \c \t is a source itself or unreachable, then it does not
     670    ///If it \c t is a source itself or unreachable, then it does not
    667671    ///alter \c p.
    668672    ///\todo Is it the right way to handle unreachable nodes?
     
    789793 
    790794    ///This function instantiates a \ref PredMap.
    791     ///\param G is the graph, to which we would like to define the PredMap.
     795    ///\param g is the graph, to which we would like to define the PredMap.
    792796    ///\todo The graph alone may be insufficient for the initialization
     797#ifdef DOXYGEN
     798    static PredMap *createPredMap(const GR &g)
     799#else
    793800    static PredMap *createPredMap(const GR &)
     801#endif
    794802    {
    795803      return new PredMap();
     
    807815 
    808816    ///This function instantiates a \ref ProcessedMap.
    809     ///\param G is the graph, to which
     817    ///\param g is the graph, to which
    810818    ///we would like to define the \ref ProcessedMap
     819#ifdef DOXYGEN
     820    static ProcessedMap *createProcessedMap(const GR &g)
     821#else
    811822    static ProcessedMap *createProcessedMap(const GR &)
     823#endif
    812824    {
    813825      return new ProcessedMap();
     
    822834 
    823835    ///This function instantiates a \ref DistMap.
    824     ///\param G is the graph, to which we would like to define the \ref DistMap
     836    ///\param g is the graph, to which we would like to define the \ref DistMap
     837#ifdef DOXYGEN
     838    static DistMap *createDistMap(const GR &g)
     839#else
    825840    static DistMap *createDistMap(const GR &)
     841#endif
    826842    {
    827843      return new DistMap();
  • lemon/error.h

    r1435 r1536  
    101101  protected:
    102102    ///\e
    103     ///\todo The good solution is boost:shared_ptr...
     103
     104    ///\todo The good solution is boost::shared_ptr...
     105    ///
    104106    mutable
    105107    std::auto_ptr<std::ostringstream> buf;
  • lemon/graph_adaptor.h

    r1472 r1536  
    452452  of edge-disjoint paths between \c s and \c t in the graph which has edge-set
    453453  all the tight edges. The computation will be demonstrated on the following
    454   graph, which is read from the dimacs file \ref sub_graph_adaptor_demo.dim.
     454  graph, which is read from the dimacs file \c sub_graph_adaptor_demo.dim.
    455455  The full source code is available in \ref sub_graph_adaptor_demo.cc.
    456456  If you are interested in more demo programs, you can use
  • lemon/graph_utils.h

    r1531 r1536  
    178178  /// }
    179179  /// \endcode
    180   /// \todo We may want to use the \ref concept::GraphBase "GraphBase"
     180  /// \todo We may want to use the "GraphBase"
    181181  /// interface here...
    182182  /// \bug Untested ...
     
    860860    ///
    861861    /// The subscript operator.
    862     /// \param edge The edge
     862    /// \param e The edge
    863863    /// \return The target of the edge
    864     Value operator[](const Key& key) {
    865       return graph.target(key);
     864    Value operator[](const Key& e) {
     865      return graph.target(e);
    866866    }
    867867
  • lemon/lp_base.h

    r1508 r1536  
    400400
    401401      ///\return
    402       ///- -\ref INF: the constraint is lower unbounded.
    403       ///- -\ref NaN: lower bound has not been set.
     402      ///- \ref INF "INF": the constraint is lower unbounded.
     403      ///- \ref NaN "NaN": lower bound has not been set.
    404404      ///- finite number: the lower bound
    405405      Value &lowerBound() { return _lb; }
     
    409409
    410410      ///\return
    411       ///- -\ref INF: the constraint is upper unbounded.
    412       ///- -\ref NaN: upper bound has not been set.
     411      ///- \ref INF "INF": the constraint is upper unbounded.
     412      ///- \ref NaN "NaN": upper bound has not been set.
    413413      ///- finite number: the upper bound
    414414      Value &upperBound() { return _ub; }
  • lemon/maps.h

    r1531 r1536  
    228228  ///Its \c Value is inherited from \c M.
    229229  ///
    230   ///Actually,
    231   ///\code
    232   ///  ConvertMap<X> sh(x,v);
    233   ///\endcode
    234   ///it is equivalent with
    235   ///\code
    236   ///  ConstMap<X::Key, X::Value> c_tmp(v);
    237   ///  AddMap<X, ConstMap<X::Key, X::Value> > sh(x,v);
    238   ///\endcode
    239230  ///\bug wrong documentation
    240231  template<class M, class T>
     
    253244
    254245    ///Constructor
    255     ///\param _m is the undelying map
    256     ///\param _v is the convert value
     246    ///\param _m is the underlying map
    257247    ConvertMap(const M &_m) : m(_m) {};
    258248
     
    260250    ///
    261251    /// The subscript operator.
    262     /// \param edge The edge
     252    /// \param k The key
    263253    /// \return The target of the edge
    264254    Value operator[](Key k) const {return m[k];}
     
    298288
    299289    ///Constructor
    300 
    301     ///\e
    302     ///
    303290    AddMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
    304291    Value operator[](Key k) const {return m1[k]+m2[k];}
     
    387374
    388375    ///Constructor
    389 
    390     ///\e
    391     ///
    392376    SubMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
    393377    Value operator[](Key k) const {return m1[k]-m2[k];}
     
    427411
    428412    ///Constructor
    429 
    430     ///\e
    431     ///
    432413    MulMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
    433414    Value operator[](Key k) const {return m1[k]*m2[k];}
     
    513494
    514495    ///Constructor
    515 
    516     ///\e
    517     ///
    518496    DivMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
    519497    Value operator[](Key k) const {return m1[k]/m2[k];}
     
    561539
    562540    ///Constructor
    563 
    564     ///\e
    565     ///
    566541    ComposeMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
    567542    Value operator[](Key k) const {return m1[m2[k]];}
     
    616591
    617592    ///Constructor
    618 
    619     ///\e
    620     ///
    621593    CombineMap(const M1 &_m1,const M2 &_m2,const F &_f)
    622594      : m1(_m1), m2(_m2), f(_f) {};
     
    667639
    668640    ///Constructor
    669 
    670     ///\e
    671     ///
    672641    NegMap(const M &_m) : m(_m) {};
    673642    Value operator[](Key k) const {return -m[k];}
     
    721690
    722691    ///Constructor
    723 
    724     ///\e
    725     ///
    726692    AbsMap(const M &_m) : m(_m) {};
    727693    Value operator[](Key k) const {Value tmp=m[k]; return tmp>=0?tmp:-tmp;}
     
    764730
    765731    ///Constructor
    766 
    767     ///\e
    768     ///
    769732    FunctorMap(const F &_f) : f(_f) {};
    770733    Value operator[](Key k) const {return f(k);}
Note: See TracChangeset for help on using the changeset viewer.