RhodeCode

\brief Reading and writing LEMON Graph Format.

This group describes methods for reading and writing

\ref lgf-format "LEMON Graph Format".

*/

/**

@defgroup eps_io Postscript Exporting

@ingroup io_group

\brief General \c EPS drawer and graph exporter

This group describes general \c EPS drawing methods and special

graph exporting tools.

*/

/**

@defgroup nauty_group NAUTY Format

@ingroup io_group

\brief Read \e Nauty format

Tool to read graphs from \e Nauty format data.

*/

/**

@defgroup concept Concepts

\brief Skeleton classes and concept checking classes

This group describes the data/algorithm skeletons and concept checking

classes implemented in LEMON.

The purpose of the classes in this group is fourfold.

- These classes contain the documentations of the %concepts. In order

  to avoid document multiplications, an implementation of a concept

  simply refers to the corresponding concept class.

#ifndef LEMON_DIMACS_H

#define LEMON_DIMACS_H

#include <iostream>

#include <string>

#include <vector>

#include <lemon/maps.h>

#include <lemon/error.h>

/// \ingroup dimacs_group

/// \file

/// \brief DIMACS file format reader.

namespace lemon {

  /// \addtogroup dimacs_group

  /// @{

  /// DIMACS file type descriptor.

  struct DimacsDescriptor

  {

    ///File type enum

    enum Type

      {

        NONE, MIN, MAX, SP, MAT

      };

    ///The file type

    Type type;

    int nodeNum;

    int edgeNum;

    int lineShift;

    /// Constructor. Sets the type to NONE.

    DimacsDescriptor() : type(NONE) {}

  };

  ///Discover the type of a DIMACS file

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

  ///that can be evaluated and passed to the appropriate reader

  ///function.

  DimacsDescriptor dimacsType(std::istream& is)

  {

    DimacsDescriptor r;

    std::string problem,str;

    char c;

    r.lineShift=0;

    while (is >> c)

      switch(c)

        {

        case 'p':

          if(is >> problem >> r.nodeNum >> r.edgeNum)

            {

              getline(is, str);

              r.lineShift++;

            {

              throw FormatError("Missing or wrong problem type declaration.");

            }

          break;

        case 'c':

          getline(is, str);

          r.lineShift++;

          break;

        default:

          throw FormatError("Unknown DIMACS declaration.");

        }

    throw FormatError("Missing problem type declaration.");

  }

  ///

  /// \code

  ///   p min

  /// \endcode

  /// At the beginning, \c g is cleared by \c g.clear(). The supply

  /// amount of the nodes are written to \c supply (signed). The

  /// lower bounds, capacities and costs of the arcs are written to

  /// \c lower, \c capacity and \c cost.

  ///

  /// If the file type was previously evaluated by dimacsType(), then

  /// the descriptor struct should be given by the \c dest parameter.

  template <typename Digraph, typename LowerMap,

            typename CapacityMap, typename CostMap,

            typename SupplyMap>

  void readDimacsMin(std::istream& is,

                     Digraph &g,

                     LowerMap& lower,

        if (desc.type==DimacsDescriptor::SP ||

            desc.type==DimacsDescriptor::MAX) {

          is >> i >> j >> _cap;

          getline(is, str);

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

          capacity.set(e, _cap);

        } else {

          is >> i >> j;

          getline(is, str);

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

        }

        break;

      }

    }

  }

  ///

  /// \code

  ///   p max

  /// \endcode

  /// At the beginning, \c g is cleared by \c g.clear(). The arc

  /// capacities are written to \c capacity and \c s and \c t are

  /// set to the source and the target nodes.

  ///

  /// If the file type was previously evaluated by dimacsType(), then

  /// the descriptor struct should be given by the \c dest parameter.

  template<typename Digraph, typename CapacityMap>

  void readDimacsMax(std::istream& is,

                     Digraph &g,

                     CapacityMap& capacity,

                     typename Digraph::Node &s,

                     typename Digraph::Node &t,

                     DimacsDescriptor desc=DimacsDescriptor()) {

    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);

    if(desc.type!=DimacsDescriptor::MAX)

      throw FormatError("Problem type mismatch");

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

  }

  /// DIMACS shortest path reader function.

  ///

  /// This function reads a shortest path instance from DIMACS format,

  /// \code

  ///   p sp

  /// \endcode

  /// At the beginning, \c g is cleared by \c g.clear(). The arc

  /// source node.

  ///

  /// If the file type was previously evaluated by dimacsType(), then

  /// the descriptor struct should be given by the \c dest parameter.

  template<typename Digraph, typename LengthMap>

  void readDimacsSp(std::istream& is,

                    Digraph &g,

                    LengthMap& length,

                    typename Digraph::Node &s,

                    DimacsDescriptor desc=DimacsDescriptor()) {

    typename Digraph::Node t;

    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);

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

      throw FormatError("Problem type mismatch");

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

  }