RhodeCode

    # C4800: 'type' : forcing value to bool 'true' or 'false'

    #        (performance warning)

    # C4996: 'function': was declared deprecated

  ELSE()

  ENDIF()

ENDIF()

SET(LEMON_CXX_WARNING_FLAGS ${CXX_WARNING} CACHE STRING "LEMON warning flags.")

SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LEMON_CXX_WARNING_FLAGS}")

    "Flags used by the C++ compiler during maintainer builds."

    FORCE )

    "Flags used by the C compiler during maintainer builds."

    FORCE )

SET( CMAKE_EXE_LINKER_FLAGS_MAINTAINER

    "-Wl,--warn-unresolved-symbols,--warn-once" CACHE STRING

        visitor.discover(arc);

        visitor.examine(arc);

      }

      _Visitor& visitor;

    };

  };

#endif

        }

        const _GraphItem &ia;

        const _GraphItem &ib;

      };

    };

    /// \brief Base skeleton class for directed graphs.

          }

        }

        const _Digraph& digraph;

      };

    };

    /// \brief Base skeleton class for undirected graphs.

          }

        }

        const _Graph& graph;

      };

    };

          ignore_unused_variable_warning(eid);

        }

        const _Digraph& digraph;

      };

    };

    /// \brief Skeleton class for \e idable undirected graphs.

          ignore_unused_variable_warning(ueid);

        }

        const _Graph& graph;

      };

    };

    /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.

          Item bi = it1;

          bi = it2;

        }

        const GR& g;

      };

    };

    /// \brief Concept class for \c InArcIt, \c OutArcIt and

          e = it2;

        }

        const Base& node;

        const GR& graph;

      };

    };

    /// \brief Skeleton class for iterable directed graphs.

          }

        }

        const _Digraph& digraph;

      };

    };

    /// \brief Skeleton class for iterable undirected graphs.

          }

        }

        const _Graph& graph;

      };

    };

    /// \brief Skeleton class for alterable directed graphs.

          ignore_unused_variable_warning(en);

        }

        const _Digraph& digraph;

      };

    };

    /// \brief Skeleton class for alterable undirected graphs.

          ignore_unused_variable_warning(uen);

        }

        const _Graph& graph;

      };

    };

    /// \brief Concept class for standard graph maps.

        const _Map &m;

        const GR &g;

        const typename GraphMap::Value &t;

      };

    };

          }

        }

        const _Digraph& digraph;

      };

    };

    /// \brief Skeleton class for mappable undirected graphs.

          }

        }

        const _Graph& graph;

      };

    };

    /// \brief Skeleton class for extendable directed graphs.

          arc = digraph.addArc(node_a, node_b);

        }

        _Digraph& digraph;

      };

    };

    /// \brief Skeleton class for extendable undirected graphs.

          edge = graph.addEdge(node_a, node_b);

        }

        _Graph& graph;

      };

    };

    /// \brief Skeleton class for erasable directed graphs.

          digraph.erase(arc);

        }

        _Digraph& digraph;

      };

    };

    /// \brief Skeleton class for erasable undirected graphs.

          graph.erase(edge);

        }

        _Graph& graph;

      };

    };

    /// \brief Skeleton class for clearable directed graphs.

          digraph.clear();

        }

        _Digraph& digraph;

      };

    };

    /// \brief Skeleton class for clearable undirected graphs.

          graph.clear();

        }

        _Graph& graph;

      };

    };

  }

        }

        _Heap& heap;

        ItemIntMap& map;

      };

    };

    /// @}

        }

        const Key& key;

        const typename _ReadMap::Key& own_key;

        const _ReadMap& m;

      };

    };

        const Value& val;

        const typename _WriteMap::Key& own_key;

        const typename _WriteMap::Value& own_val;

        _WriteMap& m;

      };

    };

    /// Read/writable map concept

      typedef T Value;

      /// Returns the value associated with the given key.

      Value operator[](const Key &) const {

      }

      /// Sets the value associated with the given key.

      void set(const Key &, const Value &) {}

    public:

      /// Returns a reference to the value associated with the given key.

      Reference operator[](const Key &) {

      }

      /// Returns a const reference to the value associated with the given key.

      ConstReference operator[](const Key &) const {

      }

      /// Sets the value associated with the given key.

      void set(const Key &k,const Value &t) { operator[](k)=t; }

        typename _ReferenceMap::Value& own_val;

        typename _ReferenceMap::Reference own_ref;

        typename _ReferenceMap::ConstReference own_cref;

        _ReferenceMap& m;

      };

    };

    // @}

          ignore_unused_variable_warning(id);

          ignore_unused_variable_warning(ed);

        }

        _Path& p;

      };

      template <typename _Digraph, typename _Path>

      struct PathDumperConstraints<

          ignore_unused_variable_warning(id);

          ignore_unused_variable_warning(ed);

        }

        _Path& p;

      };

    }

        visitor.leave(node);

        visitor.backtrack(arc);

      }

      _Visitor& visitor;

    };

  };

#endif