RhodeCode

#include <limits>

  ///It starts seeking the beginning of the file for the problem type

  /// amount of the nodes are written to the \c supply node map

  /// (they are signed values). The lower bounds, capacities and costs

  /// of the arcs are written to the \c lower, \c capacity and \c cost

  /// arc maps.

  ///

  /// If the capacity of an arc is less than the lower bound, it will

  /// be set to "infinite" instead. The actual value of "infinite" is

  /// contolled by the \c infty parameter. If it is 0 (the default value),

  /// \c std::numeric_limits<Capacity>::infinity() will be used if available,

  /// \c std::numeric_limits<Capacity>::max() otherwise. If \c infty is set to

  /// a non-zero value, that value will be used as "infinite".

                     typename CapacityMap::Value infty = 0,

    typedef typename CapacityMap::Value Capacity;

    if(infty==0)

      infty = std::numeric_limits<Capacity>::has_infinity ?

        std::numeric_limits<Capacity>::infinity() :

        std::numeric_limits<Capacity>::max();

      case 'a': // arc definition line

        if (cap >= low)

          capacity.set(e, infty);

                   typename CapacityMap::Value infty = 0,

    typedef typename CapacityMap::Value Capacity;

    if(infty==0)

      infty = std::numeric_limits<Capacity>::has_infinity ?

        std::numeric_limits<Capacity>::infinity() :

        std::numeric_limits<Capacity>::max();

      case 'a': // arc definition line

        if (desc.type==DimacsDescriptor::SP) {

        } 

        else if (desc.type==DimacsDescriptor::MAX) {

          is >> i >> j >> _cap;

          getline(is, str);

          e = g.addArc(nodes[i], nodes[j]);

          if (_cap >= 0)

            capacity.set(e, _cap);

          else

            capacity.set(e, infty);

        }

        else {

  /// capacities are written to the \c capacity arc map and \c s and

  /// \c t are set to the source and the target nodes.

  ///

  /// If the capacity of an arc is negative, it will

  /// be set to "infinite" instead. The actual value of "infinite" is

  /// contolled by the \c infty parameter. If it is 0 (the default value),

  /// \c std::numeric_limits<Capacity>::infinity() will be used if available,

  /// \c std::numeric_limits<Capacity>::max() otherwise. If \c infty is set to

  /// a non-zero value, that value will be used as "infinite".

                     typename CapacityMap::Value infty = 0,

    _readDimacs(is,g,capacity,s,t,infty,desc);

  /// lengths are written to the \c length arc map and \c s is set to the

    _readDimacs(is, g, length, s, t, 0, desc);

  /// DIMACS 'max' or 'sp' format.

  /// and the arc capacities/lengths are written to the \c capacity

  /// arc map.

  ///

  /// In case of the 'max' format, if the capacity of an arc is negative,

  /// it will

  /// be set to "infinite" instead. The actual value of "infinite" is

  /// contolled by the \c infty parameter. If it is 0 (the default value),

  /// \c std::numeric_limits<Capacity>::infinity() will be used if available,

  /// \c std::numeric_limits<Capacity>::max() otherwise. If \c infty is set to

  /// a non-zero value, that value will be used as "infinite".

                     typename CapacityMap::Value infty = 0,

    _readDimacs(is, g, capacity, u, v, infty, desc);

      case 'a': // arc definition line

               Value infty, DimacsDescriptor &desc)

  readDimacsMax(is, g, cap, s, t, infty, desc);

  std::stringstream iss(ap["infcap"]);

  Value infty;

  iss >> infty;

  if(iss.fail())

    {

      std::cerr << "Cannot interpret '"

                << static_cast<std::string>(ap["infcap"]) << "' as infinite"

                << std::endl;

      exit(1);

    }

      solve_max<Value>(ap,is,os,infty,desc);

    .stringOption("infcap","Value used for 'very high' capacities","0")

        readDimacsMin(is, digraph, lower, capacity, cost, supply, 0, desc);

        readDimacsMax(is, digraph, capacity, s, t, 0, desc);