RhodeCode

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

              << ap.files().size() << " file arguments were given. They are:\n";

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

/// and additional maps from/to a stream or a file using the

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

\page coding_style LEMON Coding Style

AllWordsCapitalizedWithoutUnderscores

firstWordLowerCaseRestCapitalizedWithoutUnderscores

ALL_UPPER_CASE_WITH_UNDERSCORES

\subsection cs-loc-var Class and instance member variables, auto variables

all_lower_case_with_underscores

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

some other classes. As a user you typically don't have to deal with these

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

The implementation of combinatorial algorithms heavily relies on

efficient graph implementations. LEMON offers data structures which are

planned to be easily used in an experimental phase of implementation studies,

and thereafter the program code can be made efficient by small modifications.

Alteration of standard containers need a very limited number of

operations, these together satisfy the everyday requirements.

In the case of graph structures, different operations are needed which do

not alter the physical graph, but gives another view. If some nodes or

this is the case. It also may happen that in a flow implementation

the residual graph can be accessed by another algorithm, or a node-set

is to be shrunk for another algorithm.

LEMON also provides a variety of graphs for these requirements called

\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only

in conjunction with other graph representations.

with any graph structures.

These classes wrap graphs to give new functionality as the adaptors do it.

@defgroup maps Maps

@defgroup graph_maps Graph Maps

\endcode

@defgroup matrices Matrices

This group describes the common graph search algorithms like

/**

@defgroup max_flow Maximum Flow algorithms

@ingroup algs

- \ref lemon::EdmondsKarp "Edmonds-Karp"

circulations.

@defgroup min_cut Minimum Cut algorithms

@ingroup algs

  in directed graphs

@defgroup matching Matching algorithms

- \ref lemon::MaxBipartiteMatching "MaxBipartiteMatching" Hopcroft-Karp

  augmenting path algorithm for calculate maximum cardinality matching in

- \ref lemon::PrBipartiteMatching "PrBipartiteMatching" Push-Relabel

  algorithm for calculate maximum cardinality matching in bipartite graphs

- \ref lemon::MaxWeightedBipartiteMatching "MaxWeightedBipartiteMatching"

  Successive shortest path algorithm for calculate maximum weighted matching

- \ref lemon::MinCostMaxBipartiteMatching "MinCostMaxBipartiteMatching"

  Successive shortest path algorithm for calculate minimum cost maximum

/**

@defgroup lp_utils Tools for Lp and Mip solvers

@defgroup utils Tools and Utilities

This group describes the tools for importing and exporting graphs

graph exporting tools.

Some utility applications are listed here.

them, as well.

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

contain whitespaces and escape sequences.

               capacity

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

If you want to get a quick start and see the most important features then

If you already feel like using our library, see the page that tells you

If you

want to see how LEMON works, see

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

        switch(i->second.type) {

        case BOOL:

          delete i->second.bool_p;

          break;

        case STRING:

          delete i->second.string_p;

          break;

        case DOUBLE:

          delete i->second.double_p;

          break;

        case INTEGER:

          delete i->second.int_p;

          break;

        case UNKNOWN:

          break;

        case FUNC:

          break;

        }

                               const std::string &help,

                               int value, bool obl)

                               const std::string &help,

                               double value, bool obl)

                               const std::string &help,

                               bool value, bool obl)

                               const std::string &help,

                               std::string value, bool obl)

                               const std::string &help,

                               int &ref, bool obl)

                               const std::string &help,

                               std::string &ref, bool obl)

                               const std::string &help,

                               void (*func)(void *),void *data)

                                    const std::string &opt)

    LEMON_ASSERT(!(i->second.ingroup),

                                const std::string &opt)

                              const std::string &help)

        if(j->second.syn&&j->second.help==i->first)

          os << "|-" << j->first;

              << "     " << i->help << std::endl;

        std::cerr << std::endl << indent;

        pos=indent.size();

        std::ostringstream cstr;

        cstr << ' ';

        if(!i->second.mandatory) cstr << '[';

        show(cstr,i);

        if(!i->second.mandatory) cstr << ']';

        if(pos+cstr.str().size()>LINE_LEN) {

          std::cerr << std::endl << indent;

          pos=indent.size();

        }

        std::cerr << cstr.str();

        pos+=cstr.str().size();

        i!=_others_help.end();++i)

        std::ostringstream cstr;

        cstr << ' ' << i->name;

        if(pos+cstr.str().size()>LINE_LEN) {

          std::cerr << std::endl << indent;

          pos=indent.size();

        }

        std::cerr << cstr.str();

        pos+=cstr.str().size();

        i!=_others_help.end();++i) showHelp(i);

  void ArgParser::unknownOpt(std::string arg)

  void ArgParser::requiresValue(std::string arg, OptType t)

      if(i->second.mandatory&&!i->second.set)

        {

          if(ok)

            std::cerr << _command_name

                      << ": The following mandatory arguments are missing.\n";

          ok=false;

          showHelp(i);

        }

        {

          int set=0;

          for(GroupData::Opts::iterator o=i->second.opts.begin();

              o!=i->second.opts.end();++o)

            if(_opts.find(*o)->second.set) ++set;

          if(i->second.mandatory&&!set) {

            std::cerr << _command_name

                      << ": At least one of the following arguments is mandatory.\n";

            ok=false;

            for(GroupData::Opts::iterator o=i->second.opts.begin();

                o!=i->second.opts.end();++o)

              showHelp(_opts.find(*o));

          }

          if(i->second.only_one&&set>1) {

            std::cerr << _command_name

                      << ": At most one of the following arguments can be given.\n";

            ok=false;

            for(GroupData::Opts::iterator o=i->second.opts.begin();

                o!=i->second.opts.end();++o)

              showHelp(_opts.find(*o));

          }

        }

        " --help' to obtain a short summary on the usage.\n\n";

        _file_args.push_back(arg);

        Opts::iterator i = _opts.find(arg.substr(1));

        if(i==_opts.end()) unknownOpt(arg);

        else {

          if(i->second.syn) i=_opts.find(i->second.help);

          ParData &p(i->second);

          if (p.type==BOOL) *p.bool_p=true;

          else if (p.type==FUNC) p.func_p.p(p.func_p.data);

          else if(++ar==_argc) requiresValue(arg, p.type);

          else {

            std::string val(_argv[ar]);

            std::istringstream vals(val);

            switch(p.type) {

            case STRING:

              *p.string_p=val;

              break;

            case INTEGER:

              vals >> *p.int_p;

              break;

            case DOUBLE:

              vals >> *p.double_p;

              break;

            default:

              break;

            }

            if(p.type!=STRING&&(!vals||!vals.eof()))

              requiresValue(arg, p.type);

          }

          p.set = true;

        }

  }

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 * This file is a part of LEMON, a generic C++ optimization library.

        bool *bool_p;

        int *int_p;

        double *double_p;

        std::string *string_p;

        struct {

          void (*p)(void *);

          void *data;

        } func_p;

                  has_syn(false), syn(false), self_delete(false) {}

    class GroupData

                    const std::string &help,

                    void (*func)(void *),void *data);

                    const std::string &help,

                    int value=0, bool obl=false);

                      const std::string &help,

                      double value=0, bool obl=false);

                      const std::string &help,

                      bool value=false, bool obl=false);

                      const std::string &help,

                      std::string value="", bool obl=false);

                     const std::string &help="");

                    const std::string &help,

                    int &ref, bool obl=false);

                      const std::string &help,

                      double &ref, bool obl=false);

                      const std::string &help,

                      bool &ref, bool obl=false);

                      const std::string &help,

                      std::string &ref, bool obl=false);

                           const std::string &opt);

                           const std::string &opt);

    ArgParser &run()

    bool given(std::string op)

    class RefType

      operator bool()

        Opts::iterator i = _parser._opts.find(_name);

        LEMON_ASSERT(i!=_parser._opts.end(),

                     std::string()+"Unkown option: '"+_name+"'");

        LEMON_ASSERT(i->second.type==ArgParser::BOOL,

                     std::string()+"'"+_name+"' is a bool option");

        return *(i->second.bool_p);

        Opts::iterator i = _parser._opts.find(_name);

        LEMON_ASSERT(i!=_parser._opts.end(),

                     std::string()+"Unkown option: '"+_name+"'");

        LEMON_ASSERT(i->second.type==ArgParser::STRING,

                     std::string()+"'"+_name+"' is a string option");

        return *(i->second.string_p);

      operator double()