RhodeCode

#if defined __GNUC__ && !defined __STRICT_ANSI__

#if defined(_MSC_VER) && (_MSC_VER < 1500)

      LPWSTR buf1, buf2, buf3;

      if (GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,

                        L"ddd MMM dd", buf1, 11) &&

          GetTimeFormat(LOCALE_USER_DEFAULT, 0, &time,

                        L"HH':'mm':'ss", buf2, 9) &&

          GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,

                        L"yyyy", buf3, 5)) {

#else

      char buf1[11], buf2[9], buf3[5];

      if (GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,

                        "ddd MMM dd", buf1, 11) &&

          GetTimeFormat(LOCALE_USER_DEFAULT, 0, &time,

                        "HH':'mm':'ss", buf2, 9) &&

          GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,

                        "yyyy", buf3, 5)) {

        os << buf1 << ' ' << buf2 << ' ' << buf3;

      }

#endif

#cmakedefine HAVE_LP 1

#cmakedefine HAVE_MIP 1

#cmakedefine HAVE_GLPK 1

  /// \brief Return a \ref DigraphReader class

  ///

  /// This function just returns a \ref DigraphReader class.

  /// \relates DigraphReader

  DigraphReader<Digraph> digraphReader(Digraph& digraph,

                                       std::istream& is = std::cin) {

    DigraphReader<Digraph> tmp(digraph, is);

    return tmp;

  }

  /// \brief Return a \ref DigraphReader class

  ///

  /// This function just returns a \ref DigraphReader class.

  /// \relates DigraphReader

  DigraphReader<Digraph> digraphReader(Digraph& digraph,

                                       const std::string& fn) {

    DigraphReader<Digraph> tmp(digraph, fn);

    return tmp;

  }

  /// \brief Return a \ref DigraphReader class

  ///

  /// This function just returns a \ref DigraphReader class.

  /// \relates DigraphReader

  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {

    DigraphReader<Digraph> tmp(digraph, fn);

    return tmp;

  }

    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,

                                                  std::istream& is);

    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,

                                                  const std::string& fn);

    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,

                                                  const char *fn);

  /// \brief Return a \ref GraphReader class

  ///

  /// This function just returns a \ref GraphReader class.

  /// \relates GraphReader

  GraphReader<Graph> graphReader(Graph& graph, std::istream& is = std::cin) {

    GraphReader<Graph> tmp(graph, is);

    return tmp;

  }

  /// \brief Return a \ref GraphReader class

  ///

  /// This function just returns a \ref GraphReader class.

  /// \relates GraphReader

  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) {

    GraphReader<Graph> tmp(graph, fn);

    return tmp;

  }

  /// \brief Return a \ref GraphReader class

  ///

  /// This function just returns a \ref GraphReader class.

  /// \relates GraphReader

  GraphReader<Graph> graphReader(Graph& graph, const char* fn) {

    GraphReader<Graph> tmp(graph, fn);

    return tmp;

  }

    friend GraphReader<Graph> graphReader<>(Graph& graph, std::istream& is);

    friend GraphReader<Graph> graphReader<>(Graph& graph,

                                            const std::string& fn);

    friend GraphReader<Graph> graphReader<>(Graph& graph, const char *fn);

  /// \brief Return a \ref DigraphWriter class

  ///

  /// This function just returns a \ref DigraphWriter class.

  /// \relates DigraphWriter

                                       std::ostream& os = std::cout) {

    DigraphWriter<Digraph> tmp(digraph, os);

    return tmp;

  }

  /// \brief Return a \ref DigraphWriter class

  ///

  /// This function just returns a \ref DigraphWriter class.

  /// \relates DigraphWriter

                                       const std::string& fn) {

    DigraphWriter<Digraph> tmp(digraph, fn);

    return tmp;

  }

  /// \brief Return a \ref DigraphWriter class

  ///

  /// This function just returns a \ref DigraphWriter class.

  /// \relates DigraphWriter

                                       const char* fn) {

    DigraphWriter<Digraph> tmp(digraph, fn);

    return tmp;

  }

    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,

                                                  std::ostream& os);

    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,

                                                  const std::string& fn);

    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,

                                                  const char *fn);

  /// \brief Return a \ref GraphWriter class

  ///

  /// This function just returns a \ref GraphWriter class.

  /// \relates GraphWriter

                                 std::ostream& os = std::cout) {

    GraphWriter<Graph> tmp(graph, os);

    return tmp;

  }

  /// \brief Return a \ref GraphWriter class

  ///

  /// This function just returns a \ref GraphWriter class.

  /// \relates GraphWriter

  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {

    GraphWriter<Graph> tmp(graph, fn);

    return tmp;

  }

  /// \brief Return a \ref GraphWriter class

  ///

  /// This function just returns a \ref GraphWriter class.

  /// \relates GraphWriter

  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {

    GraphWriter<Graph> tmp(graph, fn);

    return tmp;

  }

    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,

                                            std::ostream& os);

    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,

                                            const std::string& fn);

    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,

                                            const char *fn);

              bool buildEnable = BuildTagIndicator<Target>::value,

              bool revEnable = RevPathTagIndicator<Source>::value>

    struct PathCopySelector {

    struct PathCopySelector<Target, Source, false, true> {

    struct PathCopySelector<Target, Source, true, false> {

      static void copy(Target& target, const Source& source) {

        target.clear();

        target.build(source);

      }

    };

    template <typename Target, typename Source>

    struct PathCopySelector<Target, Source, true, true> {

    template <typename Result, int exp, bool pos = (exp >= 0)>

        if ((exp & 1) == 1) res *= static_cast<Result>(2.0);

        return res;

      }

    };

    template <typename Result, int exp>

    struct ShiftMultiplier<Result, exp, false> {

      static const Result multiplier() {

        Result res = ShiftMultiplier<Result, exp / 2>::multiplier();

        res *= res;

    struct ShiftMultiplier<Result, 0, true> {

    struct ShiftMultiplier<Result, -20, true> {

    struct ShiftMultiplier<Result, -32, true> {

        return static_cast<Result>(1.0/424967296.0);

    struct ShiftMultiplier<Result, -53, true> {

    struct ShiftMultiplier<Result, -64, true> {

        return Shifting<Result, - shift - rest>::

        return Shifting<Result, - shift - bits>::

  ///This is an abstract class, it should be specialized for all

  ///numerical data types. These specialized classes like

  ///\sa Tolerance<int>

  ///\sa Tolerance<long long int>

  ///\sa Tolerance<unsigned int>

  ///\sa Tolerance<unsigned long long int>

    static bool less(Value a,Value b) {return false;}

    static bool different(Value a,Value b) {return false;}

    static bool positive(Value a) {return false;}

    static bool negative(Value a) {return false;}

    static bool nonZero(Value a) {return false;}

    static Value zero() {return T();}

  ///Integer specialization of Tolerance.

  ///Integer specialization of Tolerance.

  ///\sa Tolerance

  template<>

  class Tolerance<int>

  {

  public:

    ///\e

    typedef int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value a) { return 0>a; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0; }

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Unsigned integer specialization of Tolerance.

  ///Unsigned integer specialization of Tolerance.

  ///\sa Tolerance

  template<>

  class Tolerance<unsigned int>

  {

  public:

    ///\e

    typedef unsigned int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value) { return false; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0; }

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Long integer specialization of Tolerance.

  ///Long integer specialization of Tolerance.

  ///\sa Tolerance

  template<>

  class Tolerance<long int>

  {

  public:

    ///\e

    typedef long int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value a) { return 0>a; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0;}

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Unsigned long integer specialization of Tolerance.

  ///Unsigned long integer specialization of Tolerance.

  ///\sa Tolerance

  template<>

  class Tolerance<unsigned long int>

  {

  public:

    ///\e

    typedef unsigned long int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value) { return false; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0;}

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

#if defined __GNUC__ && !defined __STRICT_ANSI__

  ///Long long integer specialization of Tolerance.

  ///Long long integer specialization of Tolerance.

  ///\warning This class (more exactly, type <tt>long long</tt>)

  ///is not ansi compatible.

  ///\sa Tolerance

  template<>

  class Tolerance<long long int>

  {

  public:

    ///\e

    typedef long long int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value a) { return 0>a; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0;}

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Unsigned long long integer specialization of Tolerance.

  ///Unsigned long long integer specialization of Tolerance.

  ///\warning This class (more exactly, type <tt>unsigned long long</tt>)

  ///is not ansi compatible.

  ///\sa Tolerance

  template<>

  class Tolerance<unsigned long long int>

  {

  public:

    ///\e

    typedef unsigned long long int Value;

    ///\name Comparisons

    ///See \ref lemon::Tolerance "Tolerance" for more details.

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    static bool different(Value a,Value b) { return a!=b; }

    ///Returns \c true if \c a is \e surely positive

    static bool positive(Value a) { return 0<a; }

    ///Returns \c true if \c a is \e surely negative

    static bool negative(Value) { return false; }

    ///Returns \c true if \c a is \e surely non-zero

    static bool nonZero(Value a) { return a!=0;}

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

#endif