Index: boost/graph/clustering_coefficient.hpp
===================================================================
--- boost/graph/clustering_coefficient.hpp	(Revision 76000)
+++ boost/graph/clustering_coefficient.hpp	(Arbeitskopie)
@@ -11,6 +11,7 @@
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/lookup_edge.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -20,7 +21,7 @@
     inline typename graph_traits<Graph>::degree_size_type
     possible_edges(const Graph& g, std::size_t k, directed_tag)
     {
-        function_requires< GraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::degree_size_type T;
         return T(k) * (T(k) - 1);
     }
@@ -42,7 +43,7 @@
                 directed_tag)
 
     {
-        function_requires< AdjacencyMatrixConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
         return (lookup_edge(u, v, g).second ? 1 : 0) +
                 (lookup_edge(v, u, g).second ? 1 : 0);
     }
@@ -55,7 +56,7 @@
                 typename graph_traits<Graph>::vertex_descriptor v,
                 undirected_tag)
     {
-        function_requires< AdjacencyMatrixConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
         return lookup_edge(u, v, g).second ? 1 : 0;
     }
 }
@@ -64,7 +65,7 @@
 inline typename graph_traits<Graph>::degree_size_type
 num_paths_through_vertex(const Graph& g, Vertex v)
 {
-    function_requires< AdjacencyGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::directed_category Directed;
     typedef typename graph_traits<Graph>::adjacency_iterator AdjacencyIterator;
 
@@ -81,8 +82,8 @@
 inline typename graph_traits<Graph>::degree_size_type
 num_triangles_on_vertex(const Graph& g, Vertex v)
 {
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::degree_size_type Degree;
     typedef typename graph_traits<Graph>::directed_category Directed;
     typedef typename graph_traits<Graph>::adjacency_iterator AdjacencyIterator;
@@ -119,10 +120,10 @@
 inline typename property_traits<ClusteringMap>::value_type
 all_clustering_coefficients(const Graph& g, ClusteringMap cm)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< WritablePropertyMapConcept<ClusteringMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ClusteringMap,Vertex> ));
     typedef typename property_traits<ClusteringMap>::value_type Coefficient;
 
     Coefficient sum(0);
@@ -139,10 +140,10 @@
 inline typename property_traits<ClusteringMap>::value_type
 mean_clustering_coefficient(const Graph& g, ClusteringMap cm)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< ReadablePropertyMapConcept<ClusteringMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<ClusteringMap,Vertex> ));
     typedef typename property_traits<ClusteringMap>::value_type Coefficient;
 
     Coefficient cc(0);
Index: boost/graph/bellman_ford_shortest_paths.hpp
===================================================================
--- boost/graph/bellman_ford_shortest_paths.hpp	(Revision 76000)
+++ boost/graph/bellman_ford_shortest_paths.hpp	(Arbeitskopie)
@@ -29,13 +29,14 @@
 #include <boost/graph/relax.hpp>
 #include <boost/graph/visitors.hpp>
 #include <boost/graph/named_function_params.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
   template <class Visitor, class Graph>
   struct BellmanFordVisitorConcept {
     void constraints() {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.examine_edge(e, g);
       vis.edge_relaxed(e, g);
       vis.edge_not_relaxed(e, g);
@@ -95,12 +96,12 @@
                          BinaryPredicate compare,
                          BellmanFordVisitor v)
   {
-    function_requires<EdgeListGraphConcept<EdgeListGraph> >();
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<EdgeListGraph> ));
     typedef graph_traits<EdgeListGraph> GTraits;
     typedef typename GTraits::edge_descriptor Edge;
     typedef typename GTraits::vertex_descriptor Vertex;
-    function_requires<ReadWritePropertyMapConcept<DistanceMap, Vertex> >();
-    function_requires<ReadablePropertyMapConcept<WeightMap, Edge> >();
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DistanceMap, Vertex> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<WeightMap, Edge> ));
     typedef typename property_traits<DistanceMap>::value_type D_value;
     typedef typename property_traits<WeightMap>::value_type W_value;
 
@@ -229,7 +230,7 @@
     (VertexAndEdgeListGraph& g, 
      const bgl_named_params<P, T, R>& params)
   {               
-    function_requires<VertexListGraphConcept<VertexAndEdgeListGraph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<VertexAndEdgeListGraph> ));
     return detail::bellman_dispatch
       (g, num_vertices(g),
        choose_const_pmap(get_param(params, edge_weight), g, edge_weight),
Index: boost/graph/bron_kerbosch_all_cliques.hpp
===================================================================
--- boost/graph/bron_kerbosch_all_cliques.hpp	(Revision 76000)
+++ boost/graph/bron_kerbosch_all_cliques.hpp	(Arbeitskopie)
@@ -11,6 +11,8 @@
 #include <deque>
 #include <boost/config.hpp>
 
+#include <boost/concept/assert.hpp>
+
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/lookup_edge.hpp>
 
@@ -151,7 +153,7 @@
                                 const Container& in,
                                 Container& out)
     {
-        function_requires< GraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
 
         typename graph_traits<Graph>::directed_category cat;
         typename Container::const_iterator i, end = in.end();
@@ -174,8 +176,8 @@
                         Visitor vis,
                         std::size_t min)
     {
-        function_requires< GraphConcept<Graph> >();
-        function_requires< CliqueVisitorConcept<Visitor,Clique,Graph> >();
+        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
+        BOOST_CONCEPT_ASSERT(( CliqueVisitorConcept<Visitor,Clique,Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
 
         // Is there vertex in nots that is connected to all vertices
@@ -266,15 +268,15 @@
 inline void
 bron_kerbosch_all_cliques(const Graph& g, Visitor vis, std::size_t min)
 {
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< VertexIndexGraphConcept<Graph> >();
-    function_requires< AdjacencyMatrixConcept<Graph> >(); // Structural requirement only
+    BOOST_CONCEPT_ASSERT< IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT< VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT< VertexIndexGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT< AdjacencyMatrixConcept<Graph> )); // Structural requirement only
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
     typedef std::vector<Vertex> VertexSet;
     typedef std::deque<Vertex> Clique;
-    function_requires< CliqueVisitorConcept<Visitor,Clique,Graph> >();
+    BOOST_CONCEPT_ASSERT< CliqueVisitorConcept<Visitor,Clique,Graph> ));
 
     // NOTE: We're using a deque to implement the clique, because it provides
     // constant inserts and removals at the end and also a constant size.
Index: boost/graph/undirected_dfs.hpp
===================================================================
--- boost/graph/undirected_dfs.hpp	(Revision 76000)
+++ boost/graph/undirected_dfs.hpp	(Arbeitskopie)
@@ -13,6 +13,7 @@
 
 #include <boost/graph/depth_first_search.hpp>
 #include <vector>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -32,16 +33,16 @@
        VertexColorMap vertex_color,
        EdgeColorMap edge_color)
     {
-      function_requires<IncidenceGraphConcept<IncidenceGraph> >();
-      function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
+      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
       typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
       typedef typename graph_traits<IncidenceGraph>::edge_descriptor Edge;
-      function_requires<ReadWritePropertyMapConcept<VertexColorMap,Vertex> >();
-      function_requires<ReadWritePropertyMapConcept<EdgeColorMap,Edge> >();
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<VertexColorMap,Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<EdgeColorMap,Edge> ));
       typedef typename property_traits<VertexColorMap>::value_type ColorValue;
       typedef typename property_traits<EdgeColorMap>::value_type EColorValue;
-      function_requires< ColorValueConcept<ColorValue> >();
-      function_requires< ColorValueConcept<EColorValue> >();
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<EColorValue> ));
       typedef color_traits<ColorValue> Color;
       typedef color_traits<EColorValue> EColor;
       typedef typename graph_traits<IncidenceGraph>::out_edge_iterator Iter;
@@ -94,16 +95,16 @@
        VertexColorMap vertex_color,
        EdgeColorMap edge_color)
     {
-      function_requires<IncidenceGraphConcept<IncidenceGraph> >();
-      function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
+      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
       typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
       typedef typename graph_traits<IncidenceGraph>::edge_descriptor Edge;
-      function_requires<ReadWritePropertyMapConcept<VertexColorMap,Vertex> >();
-      function_requires<ReadWritePropertyMapConcept<EdgeColorMap,Edge> >();
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<VertexColorMap,Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<EdgeColorMap,Edge> ));
       typedef typename property_traits<VertexColorMap>::value_type ColorValue;
       typedef typename property_traits<EdgeColorMap>::value_type EColorValue;
-      function_requires< ColorValueConcept<ColorValue> >();
-      function_requires< ColorValueConcept<EColorValue> >();
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<EColorValue> ));
       typedef color_traits<ColorValue> Color;
       typedef color_traits<EColorValue> EColor;
       typename graph_traits<IncidenceGraph>::out_edge_iterator ei, ei_end;
@@ -134,8 +135,8 @@
                  VertexColorMap vertex_color, EdgeColorMap edge_color,
                  Vertex start_vertex)
   {
-    function_requires<DFSVisitorConcept<DFSVisitor, Graph> >();
-      function_requires<EdgeListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
 
     typedef typename property_traits<VertexColorMap>::value_type ColorValue;
     typedef color_traits<ColorValue> Color;
Index: boost/graph/boykov_kolmogorov_max_flow.hpp
===================================================================
--- boost/graph/boykov_kolmogorov_max_flow.hpp	(Revision 76000)
+++ boost/graph/boykov_kolmogorov_max_flow.hpp	(Arbeitskopie)
@@ -47,6 +47,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/named_function_params.hpp>
 #include <boost/graph/lookup_edge.hpp>
+#include <boost/concept/assert.hpp>
 
 // The algorithm impelemented here is described in:
 //
@@ -743,16 +744,16 @@
   typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
 
   //as this method is the last one before we instantiate the solver, we do the concept checks here
-  function_requires<VertexListGraphConcept<Graph> >(); //to have vertices(), num_vertices(),
-  function_requires<EdgeListGraphConcept<Graph> >(); //to have edges()
-  function_requires<IncidenceGraphConcept<Graph> >(); //to have source(), target() and out_edges()
-  function_requires<ReadablePropertyMapConcept<CapacityEdgeMap, edge_descriptor> >(); //read flow-values from edges
-  function_requires<ReadWritePropertyMapConcept<ResidualCapacityEdgeMap, edge_descriptor> >(); //write flow-values to residuals
-  function_requires<ReadablePropertyMapConcept<ReverseEdgeMap, edge_descriptor> >(); //read out reverse edges
-  function_requires<ReadWritePropertyMapConcept<PredecessorMap, vertex_descriptor> >(); //store predecessor there
-  function_requires<ReadWritePropertyMapConcept<ColorMap, vertex_descriptor> >(); //write corresponding tree
-  function_requires<ReadWritePropertyMapConcept<DistanceMap, vertex_descriptor> >(); //write distance to source/sink
-  function_requires<ReadablePropertyMapConcept<IndexMap, vertex_descriptor> >(); //get index 0...|V|-1
+  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> )); //to have vertices(), num_vertices(),
+  BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> )); //to have edges()
+  BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> )); //to have source(), target() and out_edges()
+  BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<CapacityEdgeMap, edge_descriptor> )); //read flow-values from edges
+  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ResidualCapacityEdgeMap, edge_descriptor> )); //write flow-values to residuals
+  BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<ReverseEdgeMap, edge_descriptor> )); //read out reverse edges
+  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<PredecessorMap, vertex_descriptor> )); //store predecessor there
+  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, vertex_descriptor> )); //write corresponding tree
+  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DistanceMap, vertex_descriptor> )); //write distance to source/sink
+  BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap, vertex_descriptor> )); //get index 0...|V|-1
   BOOST_ASSERT(num_vertices(g) >= 2 && src != sink);
 
   detail::bk_max_flow<
Index: boost/graph/tiernan_all_cycles.hpp
===================================================================
--- boost/graph/tiernan_all_cycles.hpp	(Revision 76000)
+++ boost/graph/tiernan_all_cycles.hpp	(Arbeitskopie)
@@ -13,6 +13,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/properties.hpp>
+#include <boost/concept/assert.hpp>
 
 #include <boost/concept/detail/concept_def.hpp>
 namespace boost {
@@ -156,8 +157,8 @@
                     const Path& p,
                     const ClosedMatrix& m)
     {
-        function_requires< IncidenceGraphConcept<Graph> >();
-        function_requires< VertexIndexGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+        BOOST_CONCEPT_ASSERT(( VertexIndexGraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
 
         // get the vertices in question
@@ -181,7 +182,7 @@
     inline bool
     can_wrap_path(const Graph& g, const Path& p)
     {
-        function_requires< IncidenceGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
         typedef typename graph_traits<Graph>::out_edge_iterator OutIterator;
 
@@ -209,7 +210,7 @@
                 Path& p,
                 ClosedMatrix& closed)
     {
-        function_requires< IncidenceGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
         typedef typename graph_traits<Graph>::edge_descriptor Edge;
         typedef typename graph_traits<Graph>::out_edge_iterator OutIterator;
@@ -238,7 +239,7 @@
     inline bool
     exhaust_paths(const Graph& g, Path& p, ClosedMatrix& closed)
     {
-        function_requires< GraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
 
         // if there's more than one vertex in the path, this closes
@@ -272,10 +273,10 @@
                             std::size_t minlen,
                             std::size_t maxlen)
     {
-        function_requires< VertexListGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
         typedef std::vector<Vertex> Path;
-        function_requires< CycleVisitorConcept<Visitor,Path,Graph> >();
+        BOOST_CONCEPT_ASSERT(( CycleVisitorConcept<Visitor,Path,Graph> ));
         typedef std::vector<Vertex> VertexList;
         typedef std::vector<VertexList> ClosedMatrix;
 
@@ -320,7 +321,7 @@
                     std::size_t minlen,
                     std::size_t maxlen)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
 
     VertexIterator i, end;
Index: boost/graph/detail/geodesic.hpp
===================================================================
--- boost/graph/detail/geodesic.hpp	(Revision 76000)
+++ boost/graph/detail/geodesic.hpp	(Arbeitskopie)
@@ -11,6 +11,7 @@
 #include <boost/config.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/numeric_values.hpp>
+#include <boost/concept/assert.hpp>
 
 // TODO: Should this really be in detail?
 
@@ -51,13 +52,13 @@
                         Combinator combine,
                         Distance init)
     {
-        function_requires< VertexListGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
         typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-        function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
-        function_requires< NumericValueConcept<Distance> >();
+        BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<Distance> ));
         typedef numeric_values<Distance> DistanceNumbers;
-        function_requires< AdaptableBinaryFunction<Combinator,Distance,Distance,Distance> >();
+        BOOST_CONCEPT_ASSERT(( AdaptableBinaryFunction<Combinator,Distance,Distance,Distance> ));
 
         // If there's ever an infinite distance, then we simply return
         // infinity. Note that this /will/ include the a non-zero
Index: boost/graph/core_numbers.hpp
===================================================================
--- boost/graph/core_numbers.hpp	(Revision 76000)
+++ boost/graph/core_numbers.hpp	(Arbeitskopie)
@@ -15,6 +15,7 @@
 #include <boost/pending/indirect_cmp.hpp>
 #include <boost/graph/breadth_first_search.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
+#include <boost/concept/assert.hpp>
 
 /*
  * core_numbers
@@ -46,7 +47,7 @@
     struct CoreNumbersVisitorConcept {
         void constraints()
         {
-            function_requires< CopyConstructibleConcept<Visitor> >();
+            BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
             vis.examine_vertex(u,g);
             vis.finish_vertex(u,g);
             vis.examine_edge(e,g);
Index: boost/graph/degree_centrality.hpp
===================================================================
--- boost/graph/degree_centrality.hpp	(Revision 76000)
+++ boost/graph/degree_centrality.hpp	(Arbeitskopie)
@@ -8,6 +8,7 @@
 #define BOOST_GRAPH_DEGREE_CENTRALITY_HPP
 
 #include <boost/graph/graph_concepts.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -28,7 +29,7 @@
 
     inline degree_type operator ()(vertex_type v, const Graph& g)
     {
-        function_requires< IncidenceGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
         return out_degree(v, g);
     }
 };
@@ -49,7 +50,7 @@
 
     inline degree_type operator ()(vertex_type v, const Graph& g)
     {
-        function_requires< BidirectionalGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
         return in_degree(v, g);
     }
 };
@@ -64,7 +65,7 @@
 inline typename Measure::degree_type
 degree_centrality(const Graph& g, Vertex v, Measure measure)
 {
-    function_requires< DegreeMeasureConcept<Measure, Graph> >();
+    BOOST_CONCEPT_ASSERT(( DegreeMeasureConcept<Measure, Graph> ));
     return measure(v, g);
 }
 
@@ -94,10 +95,10 @@
 inline void
 all_degree_centralities(const Graph& g, CentralityMap cent, Measure measure)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< WritablePropertyMapConcept<CentralityMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<CentralityMap,Vertex> ));
     typedef typename property_traits<CentralityMap>::value_type Centrality;
 
     VertexIterator i, end;
Index: boost/graph/kruskal_min_spanning_tree.hpp
===================================================================
--- boost/graph/kruskal_min_spanning_tree.hpp	(Revision 76000)
+++ boost/graph/kruskal_min_spanning_tree.hpp	(Arbeitskopie)
@@ -28,6 +28,7 @@
 #include <boost/graph/named_function_params.hpp>
 #include <boost/pending/disjoint_sets.hpp>
 #include <boost/pending/indirect_cmp.hpp>
+#include <boost/concept/assert.hpp>
 
 
 namespace boost {
@@ -51,18 +52,18 @@
       if (num_vertices(G) == 0) return; // Nothing to do in this case
       typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
       typedef typename graph_traits<Graph>::edge_descriptor Edge;
-      function_requires<VertexListGraphConcept<Graph> >();
-      function_requires<EdgeListGraphConcept<Graph> >();
-      function_requires<OutputIteratorConcept<OutputIterator, Edge> >();
-      function_requires<ReadWritePropertyMapConcept<Rank, Vertex> >();
-      function_requires<ReadWritePropertyMapConcept<Parent, Vertex> >();
-      function_requires<ReadablePropertyMapConcept<Weight, Edge> >();
+      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+      BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+      BOOST_CONCEPT_ASSERT(( OutputIteratorConcept<OutputIterator, Edge> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<Rank, Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<Parent, Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<Weight, Edge> ));
       typedef typename property_traits<Weight>::value_type W_value;
       typedef typename property_traits<Rank>::value_type R_value;
       typedef typename property_traits<Parent>::value_type P_value;
-      function_requires<ComparableConcept<W_value> >();
-      function_requires<ConvertibleConcept<P_value, Vertex> >();
-      function_requires<IntegerConcept<R_value> >();
+      BOOST_CONCEPT_ASSERT(( ComparableConcept<W_value> ));
+      BOOST_CONCEPT_ASSERT(( ConvertibleConcept<P_value, Vertex> ));
+      BOOST_CONCEPT_ASSERT(( IntegerConcept<R_value> ));
 
       disjoint_sets<Rank, Parent>  dset(rank, parent);
 
Index: boost/graph/dijkstra_shortest_paths.hpp
===================================================================
--- boost/graph/dijkstra_shortest_paths.hpp	(Revision 76000)
+++ boost/graph/dijkstra_shortest_paths.hpp	(Arbeitskopie)
@@ -30,6 +30,7 @@
 #include <boost/property_map/property_map.hpp>
 #include <boost/property_map/vector_property_map.hpp>
 #include <boost/type_traits.hpp>
+#include <boost/concept/assert.hpp>
 
 #ifdef BOOST_GRAPH_DIJKSTRA_TESTING
 #  include <boost/pending/mutable_queue.hpp>
@@ -68,7 +69,7 @@
   template <class Visitor, class Graph>
   struct DijkstraVisitorConcept {
     void constraints() {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.initialize_vertex(u, g);
       vis.discover_vertex(u, g);
       vis.examine_vertex(u, g);
Index: boost/graph/floyd_warshall_shortest.hpp
===================================================================
--- boost/graph/floyd_warshall_shortest.hpp	(Revision 76000)
+++ boost/graph/floyd_warshall_shortest.hpp	(Arbeitskopie)
@@ -34,6 +34,7 @@
 #include <boost/graph/named_function_params.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/relax.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -84,7 +85,7 @@
     const BinaryFunction& combine, const Infinity& inf, 
     const Zero& zero)
   {
-    function_requires<VertexListGraphConcept<VertexListGraph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<VertexListGraph> ));
   
     return detail::floyd_warshall_dispatch(g, d, compare, combine, 
     inf, zero);
@@ -101,9 +102,9 @@
     const BinaryPredicate& compare, const BinaryFunction& combine, 
     const Infinity& inf, const Zero& zero)
   {
-    function_requires<VertexListGraphConcept<VertexAndEdgeListGraph> >();
-    function_requires<EdgeListGraphConcept<VertexAndEdgeListGraph> >();
-    function_requires<IncidenceGraphConcept<VertexAndEdgeListGraph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<VertexAndEdgeListGraph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<VertexAndEdgeListGraph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<VertexAndEdgeListGraph> ));
   
     typename graph_traits<VertexAndEdgeListGraph>::vertex_iterator 
       firstv, lastv, firstv2, lastv2;
Index: boost/graph/johnson_all_pairs_shortest.hpp
===================================================================
--- boost/graph/johnson_all_pairs_shortest.hpp	(Revision 76000)
+++ boost/graph/johnson_all_pairs_shortest.hpp	(Arbeitskopie)
@@ -29,6 +29,7 @@
 #include <boost/graph/dijkstra_shortest_paths.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/type_traits/same_traits.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -44,8 +45,8 @@
   {
     typedef graph_traits<VertexAndEdgeListGraph> Traits1;
     typedef typename property_traits<Weight>::value_type DT;
-    function_requires< BasicMatrixConcept<DistanceMatrix,
-      typename Traits1::vertices_size_type, DT> >();
+    BOOST_CONCEPT_ASSERT(( BasicMatrixConcept<DistanceMatrix,
+      typename Traits1::vertices_size_type, DT> ));
 
     typedef typename Traits1::directed_category DirCat;
     bool is_undirected = is_same<DirCat, undirected_tag>::value;
Index: boost/graph/connected_components.hpp
===================================================================
--- boost/graph/connected_components.hpp	(Revision 76000)
+++ boost/graph/connected_components.hpp	(Arbeitskopie)
@@ -17,6 +17,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/overloading.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -64,7 +65,7 @@
     if (num_vertices(g) == 0) return 0;
 
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< WritablePropertyMapConcept<ComponentMap, Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, Vertex> ));
     typedef typename boost::graph_traits<Graph>::directed_category directed;
     BOOST_STATIC_ASSERT((boost::is_same<directed, undirected_tag>::value));
 
@@ -84,7 +85,7 @@
     if (num_vertices(g) == 0) return 0;
 
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< WritablePropertyMapConcept<ComponentMap, Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, Vertex> ));
     typedef typename boost::graph_traits<Graph>::directed_category directed;
     // BOOST_STATIC_ASSERT((boost::is_same<directed, undirected_tag>::value));
 
Index: boost/graph/isomorphism.hpp
===================================================================
--- boost/graph/isomorphism.hpp	(Revision 76000)
+++ boost/graph/isomorphism.hpp	(Arbeitskopie)
@@ -15,6 +15,7 @@
 #include <boost/utility.hpp>
 #include <boost/detail/algorithm.hpp>
 #include <boost/pending/indirect_cmp.hpp> // for make_indirect_pmap
+#include <boost/concept/assert.hpp>
 
 #ifndef BOOST_GRAPH_ITERATION_MACROS_HPP
 #define BOOST_ISO_INCLUDED_ITER_MACROS // local macro, see bottom of file
@@ -322,31 +323,31 @@
 
   {
     // Graph requirements
-    function_requires< VertexListGraphConcept<Graph1> >();
-    function_requires< EdgeListGraphConcept<Graph1> >();
-    function_requires< VertexListGraphConcept<Graph2> >();
-    function_requires< BidirectionalGraphConcept<Graph2> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
     
     typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_t;
     typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
     typedef typename graph_traits<Graph1>::vertices_size_type size_type;
     
     // Vertex invariant requirement
-    function_requires< AdaptableUnaryFunctionConcept<Invariant1,
-      size_type, vertex1_t> >();
-    function_requires< AdaptableUnaryFunctionConcept<Invariant2,
-      size_type, vertex2_t> >();
+    BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant1,
+      size_type, vertex1_t> ));
+    BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant2,
+      size_type, vertex2_t> ));
     
     // Property map requirements
-    function_requires< ReadWritePropertyMapConcept<IsoMapping, vertex1_t> >();
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IsoMapping, vertex1_t> ));
     typedef typename property_traits<IsoMapping>::value_type IsoMappingValue;
     BOOST_STATIC_ASSERT((is_same<IsoMappingValue, vertex2_t>::value));
     
-    function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
     typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
     BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
     
-    function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
     typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
     BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
     
Index: boost/graph/dominator_tree.hpp
===================================================================
--- boost/graph/dominator_tree.hpp	(Revision 76000)
+++ boost/graph/dominator_tree.hpp	(Arbeitskopie)
@@ -13,6 +13,7 @@
 #include <deque>
 #include <set>
 #include <boost/graph/depth_first_search.hpp>
+#include <boost/concept/assert.hpp>
 
 // Dominator tree computation
 
@@ -244,7 +245,7 @@
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertices_size_type VerticesSizeType;
 
-    function_requires< BidirectionalGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
 
     const VerticesSizeType numOfVertices = num_vertices(g);
     if (numOfVertices == 0) return;
@@ -299,7 +300,7 @@
     // Typedefs and concept check
     typedef typename graph_traits<Graph>::vertices_size_type VerticesSizeType;
 
-    function_requires< BidirectionalGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
 
     // 1. Depth first visit
     const VerticesSizeType numOfVertices = num_vertices(g);
@@ -388,7 +389,7 @@
       iterator_property_map<typename std::vector< std::set<Vertex> >::iterator,
                             IndexMap> vertexSetMap;
 
-    function_requires<BidirectionalGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
 
     // 1. Finding dominator
     // 1.1. Initialize
Index: boost/graph/biconnected_components.hpp
===================================================================
--- boost/graph/biconnected_components.hpp	(Revision 76000)
+++ boost/graph/biconnected_components.hpp	(Arbeitskopie)
@@ -20,6 +20,7 @@
 #include <boost/property_map/property_map.hpp>
 #include <boost/graph/depth_first_search.hpp>
 #include <boost/graph/graph_utility.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -157,14 +158,14 @@
   {
     typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
     typedef typename graph_traits<Graph>::edge_descriptor edge_t;
-    function_requires<VertexListGraphConcept<Graph> >();
-    function_requires<IncidenceGraphConcept<Graph> >();
-    function_requires<WritablePropertyMapConcept<ComponentMap, edge_t> >();
-    function_requires<ReadWritePropertyMapConcept<DiscoverTimeMap,
-                                                  vertex_t> >();
-    function_requires<ReadWritePropertyMapConcept<LowPointMap, vertex_t > >();
-    function_requires<ReadWritePropertyMapConcept<PredecessorMap,
-                                                  vertex_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, edge_t> ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DiscoverTimeMap,
+                                                  vertex_t> ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<LowPointMap, vertex_t > ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<PredecessorMap,
+                                                  vertex_t> ));
 
     std::size_t num_components = 0;
     std::size_t dfs_time = 0;
Index: boost/graph/transitive_closure.hpp
===================================================================
--- boost/graph/transitive_closure.hpp	(Revision 76000)
+++ boost/graph/transitive_closure.hpp	(Arbeitskopie)
@@ -19,6 +19,7 @@
 #include <boost/graph/topological_sort.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/named_function_params.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -76,12 +77,12 @@
     typedef typename graph_traits <
       Graph >::adjacency_iterator adjacency_iterator;
 
-    function_requires < VertexListGraphConcept < Graph > >();
-    function_requires < AdjacencyGraphConcept < Graph > >();
-    function_requires < VertexMutableGraphConcept < GraphTC > >();
-    function_requires < EdgeMutableGraphConcept < GraphTC > >();
-    function_requires < ReadablePropertyMapConcept < VertexIndexMap,
-      vertex > >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept < Graph > ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept < Graph > ));
+    BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept < GraphTC > ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept < GraphTC > ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept < VertexIndexMap,
+      vertex > ));
 
     typedef size_type cg_vertex;
     std::vector < cg_vertex > component_number_vec(num_vertices(g));
@@ -302,8 +303,8 @@
     typedef typename graph_traits < G >::vertex_descriptor vertex;
     typedef typename graph_traits < G >::vertex_iterator vertex_iterator;
 
-    function_requires < AdjacencyMatrixConcept < G > >();
-    function_requires < EdgeMutableGraphConcept < G > >();
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept < G > ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept < G > ));
 
     // Matrix form:
     // for k
@@ -328,8 +329,8 @@
     typedef typename graph_traits < G >::vertex_descriptor vertex;
     typedef typename graph_traits < G >::vertex_iterator vertex_iterator;
 
-    function_requires < AdjacencyMatrixConcept < G > >();
-    function_requires < EdgeMutableGraphConcept < G > >();
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept < G > ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept < G > ));
 
     // Make sure second loop will work
     if (num_vertices(g) == 0)
Index: boost/graph/eccentricity.hpp
===================================================================
--- boost/graph/eccentricity.hpp	(Revision 76000)
+++ boost/graph/eccentricity.hpp	(Arbeitskopie)
@@ -10,6 +10,7 @@
 #include <boost/utility.hpp>
 #include <boost/config.hpp>
 #include <boost/graph/detail/geodesic.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -19,9 +20,9 @@
 inline typename property_traits<DistanceMap>::value_type
 eccentricity(const Graph& g, DistanceMap dist, Combinator combine)
 {
-    function_requires< GraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     typedef typename property_traits<DistanceMap>::value_type Distance;
 
     return detail::combine_distances(g, dist, combine, Distance(0));
@@ -31,9 +32,9 @@
 inline typename property_traits<DistanceMap>::value_type
 eccentricity(const Graph& g, DistanceMap dist)
 {
-    function_requires< GraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     typedef typename property_traits<DistanceMap>::value_type Distance;
 
     return eccentricity(g, dist, detail::maximize<Distance>());
@@ -44,12 +45,12 @@
                     typename property_traits<EccentricityMap>::value_type>
 all_eccentricities(const Graph& g, const DistanceMatrix& dist, EccentricityMap ecc)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< ReadablePropertyMapConcept<DistanceMatrix,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrix,Vertex> ));
     typedef typename property_traits<DistanceMatrix>::value_type DistanceMap;
-    function_requires< WritablePropertyMapConcept<EccentricityMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<EccentricityMap,Vertex> ));
     typedef typename property_traits<EccentricityMap>::value_type Eccentricity;
     BOOST_USING_STD_MIN();
     BOOST_USING_STD_MAX();
@@ -76,10 +77,10 @@
                     typename property_traits<EccentricityMap>::value_type>
 radius_and_diameter(const Graph& g, EccentricityMap ecc)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< ReadablePropertyMapConcept<EccentricityMap, Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<EccentricityMap, Vertex> ));
     typedef typename property_traits<EccentricityMap>::value_type Eccentricity;
     BOOST_USING_STD_MIN();
     BOOST_USING_STD_MAX();
Index: boost/graph/closeness_centrality.hpp
===================================================================
--- boost/graph/closeness_centrality.hpp	(Revision 76000)
+++ boost/graph/closeness_centrality.hpp	(Arbeitskopie)
@@ -9,6 +9,7 @@
 
 #include <boost/graph/detail/geodesic.hpp>
 #include <boost/graph/exterior_property.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -25,9 +26,9 @@
 
     result_type operator ()(distance_type d, const Graph&)
     {
-        function_requires< NumericValueConcept<DistanceType> >();
-        function_requires< NumericValueConcept<ResultType> >();
-        function_requires< AdaptableUnaryFunctionConcept<Reciprocal,ResultType,ResultType> >();
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<DistanceType> ));
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<ResultType> ));
+        BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Reciprocal,ResultType,ResultType> ));
         return (d == base_type::infinite_distance())
             ? base_type::zero_result()
             : rec(result_type(d));
@@ -75,12 +76,12 @@
                      Measure measure,
                      Combinator combine)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     typedef typename property_traits<DistanceMap>::value_type Distance;
-    function_requires< NumericValueConcept<Distance> >();
-    function_requires< DistanceMeasureConcept<Measure,Graph> >();
+    BOOST_CONCEPT_ASSERT(( NumericValueConcept<Distance> ));
+    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
 
     Distance n = detail::combine_distances(g, dist, combine, Distance(0));
     return measure(n, g);
@@ -90,9 +91,9 @@
 inline typename Measure::result_type
 closeness_centrality(const Graph& g, DistanceMap dist, Measure measure)
 {
-    function_requires< GraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     typedef typename property_traits<DistanceMap>::value_type Distance;
 
     return closeness_centrality(g, dist, measure, std::plus<Distance>());
@@ -116,12 +117,12 @@
                            CentralityMap cent,
                            Measure measure)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
     typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
-    function_requires< WritablePropertyMapConcept<CentralityMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<CentralityMap,Vertex> ));
     typedef typename property_traits<DistanceMap>::value_type Distance;
     typedef typename property_traits<CentralityMap>::value_type Centrality;
 
@@ -141,11 +142,11 @@
                             DistanceMatrixMap dist,
                             CentralityMap cent)
 {
-    function_requires< GraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
     typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     typedef typename property_traits<DistanceMap>::value_type Distance;
     typedef typename property_traits<CentralityMap>::value_type Result;
 
Index: boost/graph/strong_components.hpp
===================================================================
--- boost/graph/strong_components.hpp	(Revision 76000)
+++ boost/graph/strong_components.hpp	(Arbeitskopie)
@@ -18,6 +18,7 @@
 #include <boost/type_traits/conversion_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/graph/overloading.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -93,11 +94,11 @@
        const bgl_named_params<P, T, R>& params)
     {
       typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-      function_requires< ReadWritePropertyMapConcept<ComponentMap, Vertex> >();
-      function_requires< ReadWritePropertyMapConcept<RootMap, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ComponentMap, Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<RootMap, Vertex> ));
       typedef typename property_traits<RootMap>::value_type RootV;
-      function_requires< ConvertibleConcept<RootV, Vertex> >();
-      function_requires< ReadWritePropertyMapConcept<DiscoverTime, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( ConvertibleConcept<RootV, Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DiscoverTime, Vertex> ));
 
       typename property_traits<ComponentMap>::value_type total = 0;
 
@@ -282,7 +283,7 @@
   kosaraju_strong_components(Graph& G, ComponentsMap c,
                              FinishTime finish_time, ColorMap color)
   {
-    function_requires< MutableGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( MutableGraphConcept<Graph> ));
     // ...
     
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
Index: boost/graph/graph_concepts.hpp
===================================================================
--- boost/graph/graph_concepts.hpp	(Revision 76000)
+++ boost/graph/graph_concepts.hpp	(Arbeitskopie)
@@ -21,6 +21,7 @@
 #include <boost/graph/buffer_concepts.hpp>
 #include <boost/concept_check.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/concept/assert.hpp>
 
 #include <boost/concept/detail/concept_def.hpp>
 namespace boost
@@ -529,8 +530,8 @@
     {
         BOOST_CONCEPT_USAGE(NumericValue)
         {
-            function_requires< DefaultConstructible<Numeric> >();
-            function_requires< CopyConstructible<Numeric> >();
+            BOOST_CONCEPT_ASSERT(( DefaultConstructible<Numeric> ));
+            BOOST_CONCEPT_ASSERT(( CopyConstructible<Numeric> ));
             numeric_values<Numeric>::zero();
             numeric_values<Numeric>::infinity();
         }
Index: boost/graph/depth_first_search.hpp
===================================================================
--- boost/graph/depth_first_search.hpp	(Revision 76000)
+++ boost/graph/depth_first_search.hpp	(Arbeitskopie)
@@ -21,6 +21,7 @@
 #include <boost/graph/named_function_params.hpp>
 #include <boost/ref.hpp>
 #include <boost/implicit_cast.hpp>
+#include <boost/concept/assert.hpp>
 
 #include <vector>
 #include <utility>
@@ -31,7 +32,7 @@
   class DFSVisitorConcept {
   public:
     void constraints() {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.initialize_vertex(u, g);
       vis.start_vertex(u, g);
       vis.discover_vertex(u, g);
@@ -80,12 +81,12 @@
        DFSVisitor& vis,
        ColorMap color, TerminatorFunc func = TerminatorFunc())
     {
-      function_requires<IncidenceGraphConcept<IncidenceGraph> >();
-      function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
+      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
       typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
-      function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
       typedef typename property_traits<ColorMap>::value_type ColorValue;
-      function_requires< ColorValueConcept<ColorValue> >();
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
       typedef color_traits<ColorValue> Color;
       typedef typename graph_traits<IncidenceGraph>::out_edge_iterator Iter;
       typedef std::pair<Vertex, std::pair<Iter, Iter> > VertexInfo;
@@ -151,12 +152,12 @@
        DFSVisitor& vis,  // pass-by-reference here, important!
        ColorMap color, TerminatorFunc func)
     {
-      function_requires<IncidenceGraphConcept<IncidenceGraph> >();
-      function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
+      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
       typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
-      function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
       typedef typename property_traits<ColorMap>::value_type ColorValue;
-      function_requires< ColorValueConcept<ColorValue> >();
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
       typedef color_traits<ColorValue> Color;
       typename graph_traits<IncidenceGraph>::out_edge_iterator ei, ei_end;
 
@@ -187,7 +188,7 @@
                      typename graph_traits<VertexListGraph>::vertex_descriptor start_vertex)
   {
     typedef typename graph_traits<VertexListGraph>::vertex_descriptor Vertex;
-    function_requires<DFSVisitorConcept<DFSVisitor, VertexListGraph> >();
+    BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, VertexListGraph> ));
     typedef typename property_traits<ColorMap>::value_type ColorValue;
     typedef color_traits<ColorValue> Color;
 
Index: boost/graph/distributed/concepts.hpp
===================================================================
--- boost/graph/distributed/concepts.hpp	(Revision 76000)
+++ boost/graph/distributed/concepts.hpp	(Arbeitskopie)
@@ -21,6 +21,7 @@
 #include <boost/version.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_concepts.hpp>
+#include <boost/concept/assert.hpp>
 
 #if BOOST_VERSION >= 103500
 #  include <boost/concept/detail/concept_def.hpp>
@@ -46,10 +47,10 @@
   typedef typename graph_traits<G>::traversal_category
     traversal_category;
   void constraints() {
-    function_requires< GraphConcept<G> >();
-    function_requires< MultiPassInputIteratorConcept<vertex_iterator> >();
-    function_requires< ConvertibleConcept<traversal_category,
-      distributed_vertex_list_graph_tag> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<G> ));
+    BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept<vertex_iterator> ));
+    BOOST_CONCEPT_ASSERT(( ConvertibleConcept<traversal_category,
+      distributed_vertex_list_graph_tag> ));
 
 #ifdef BOOST_VECTOR_AS_GRAPH_GRAPH_ADL_HACK
     // dwa 2003/7/11 -- This clearly shouldn't be necessary, but if
@@ -92,13 +93,13 @@
   typedef typename graph_traits<G>::traversal_category
     traversal_category;
   void constraints() {
-    function_requires< GraphConcept<G> >();
-    function_requires< MultiPassInputIteratorConcept<edge_iterator> >();
-    function_requires< DefaultConstructibleConcept<edge_descriptor> >();
-    function_requires< EqualityComparableConcept<edge_descriptor> >();
-    function_requires< AssignableConcept<edge_descriptor> >();
-    function_requires< ConvertibleConcept<traversal_category,
-      distributed_edge_list_graph_tag> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<G> ));
+    BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept<edge_iterator> ));
+    BOOST_CONCEPT_ASSERT(( DefaultConstructibleConcept<edge_descriptor> ));
+    BOOST_CONCEPT_ASSERT(( EqualityComparableConcept<edge_descriptor> ));
+    BOOST_CONCEPT_ASSERT(( AssignableConcept<edge_descriptor> ));
+    BOOST_CONCEPT_ASSERT(( ConvertibleConcept<traversal_category,
+      distributed_edge_list_graph_tag> ));
 
     p = edges(g);
     e = *p.first;
Index: boost/graph/distributed/hohberg_biconnected_components.hpp
===================================================================
--- boost/graph/distributed/hohberg_biconnected_components.hpp	(Revision 76000)
+++ boost/graph/distributed/hohberg_biconnected_components.hpp	(Arbeitskopie)
@@ -44,6 +44,7 @@
 #include <vector>
 #include <boost/graph/parallel/algorithm.hpp>
 #include <boost/graph/distributed/connected_components.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost { namespace graph { namespace distributed {
 
@@ -908,7 +909,7 @@
                     undirected_tag>::value));
 
   // The graph must model Incidence Graph
-  function_requires< IncidenceGraphConcept<Graph> >();
+  BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
 
   typedef typename graph_traits<Graph>::edges_size_type edges_size_type;
   typedef typename graph_traits<Graph>::degree_size_type degree_size_type;
Index: boost/graph/geodesic_distance.hpp
===================================================================
--- boost/graph/geodesic_distance.hpp	(Revision 76000)
+++ boost/graph/geodesic_distance.hpp	(Arbeitskopie)
@@ -9,6 +9,7 @@
 
 #include <boost/graph/detail/geodesic.hpp>
 #include <boost/graph/exterior_property.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -25,10 +26,10 @@
 
     result_type operator ()(distance_type d, const Graph& g)
     {
-        function_requires< VertexListGraphConcept<Graph> >();
-        function_requires< NumericValueConcept<DistanceType> >();
-        function_requires< NumericValueConcept<ResultType> >();
-        function_requires< AdaptableBinaryFunctionConcept<Divides,ResultType,ResultType,ResultType> >();
+        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<DistanceType> ));
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<ResultType> ));
+        BOOST_CONCEPT_ASSERT(( AdaptableBinaryFunctionConcept<Divides,ResultType,ResultType,ResultType> ));
 
         return (d == base_type::infinite_distance())
             ? base_type::infinite_result()
@@ -69,8 +70,8 @@
 
     inline result_type operator ()(distance_type d, const Graph& g)
     {
-        function_requires< VertexListGraphConcept<Graph> >();
-        function_requires< NumericValueConcept<DistanceType> >();
+        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<DistanceType> ));
 
         if(d == base_type::infinite_distance()) {
             return base_type::infinite_result();
@@ -99,7 +100,7 @@
                 Measure measure,
                 Combinator combine)
 {
-    function_requires< DistanceMeasureConcept<Measure,Graph> >();
+    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
     typedef typename Measure::distance_type Distance;
 
     Distance n = detail::combine_distances(g, dist, combine, Distance(0));
@@ -112,7 +113,7 @@
 inline typename Measure::result_type
 mean_geodesic(const Graph& g, DistanceMap dist, Measure measure)
 {
-    function_requires< DistanceMeasureConcept<Measure,Graph> >();
+    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
     typedef typename Measure::distance_type Distance;
 
     return mean_geodesic(g, dist, measure, std::plus<Distance>());
@@ -139,15 +140,15 @@
                     GeodesicMap geo,
                     Measure measure)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
     typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
-    function_requires< DistanceMeasureConcept<Measure,Graph> >();
+    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
     typedef typename Measure::result_type Result;
-    function_requires< WritablePropertyMapConcept<GeodesicMap,Vertex> >();
-    function_requires< NumericValueConcept<Result> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<GeodesicMap,Vertex> ));
+    BOOST_CONCEPT_ASSERT(( NumericValueConcept<Result> ));
 
     // NOTE: We could compute the mean geodesic here by performing additional
     // computations (i.e., adding and dividing). However, I don't really feel
@@ -178,11 +179,11 @@
 inline typename property_traits<GeodesicMap>::value_type
 all_mean_geodesics(const Graph& g, DistanceMatrixMap dist, GeodesicMap geo)
 {
-    function_requires< GraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
     typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
-    function_requires< WritablePropertyMapConcept<GeodesicMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<GeodesicMap,Vertex> ));
     typedef typename property_traits<GeodesicMap>::value_type Result;
 
     return all_mean_geodesics(g, dist, geo, measure_mean_geodesic<Result>(g, DistanceMap()));
@@ -193,7 +194,7 @@
 inline typename Measure::result_type
 small_world_distance(const Graph& g, GeodesicMap geo, Measure measure)
 {
-    function_requires< DistanceMeasureConcept<Measure,Graph> >();
+    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
     typedef typename Measure::result_type Result;
 
     Result sum = detail::combine_distances(g, geo, std::plus<Result>(), Result(0));
Index: boost/graph/astar_search.hpp
===================================================================
--- boost/graph/astar_search.hpp	(Revision 76000)
+++ boost/graph/astar_search.hpp	(Arbeitskopie)
@@ -25,8 +25,8 @@
 #include <boost/graph/detail/d_ary_heap.hpp>
 #include <boost/property_map/property_map.hpp>
 #include <boost/property_map/vector_property_map.hpp>
+#include <boost/concept/assert.hpp>
 
-
 namespace boost {
 
 
@@ -34,7 +34,7 @@
   struct AStarHeuristicConcept {
     void constraints()
     {
-      function_requires< CopyConstructibleConcept<Heuristic> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Heuristic> ));
       h(u);
     }
     Heuristic h;
@@ -58,7 +58,7 @@
   struct AStarVisitorConcept {
     void constraints()
     {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.initialize_vertex(u, g);
       vis.discover_vertex(u, g);
       vis.examine_vertex(u, g);
Index: boost/graph/howard_cycle_ratio.hpp
===================================================================
--- boost/graph/howard_cycle_ratio.hpp	(Revision 76000)
+++ boost/graph/howard_cycle_ratio.hpp	(Arbeitskopie)
@@ -20,6 +20,7 @@
 #include <boost/property_map/property_map.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_concepts.hpp>
+#include <boost/concept/assert.hpp>
 
 /** @file howard_cycle_ratio.hpp
  * @brief The implementation of the maximum/minimum cycle ratio/mean algorithm.
@@ -477,13 +478,13 @@
     {
       typedef typename graph_traits<TG>::directed_category DirCat;
       BOOST_STATIC_ASSERT((is_convertible<DirCat*, directed_tag*>::value == true));
-      function_requires< IncidenceGraphConcept<TG> >();
-      function_requires< VertexListGraphConcept<TG> >();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<TG> ));
+      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<TG> ));
       typedef typename graph_traits<TG>::vertex_descriptor Vertex;
-      function_requires< ReadablePropertyMapConcept<TVIM, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<TVIM, Vertex> ));
       typedef typename graph_traits<TG>::edge_descriptor Edge;
-      function_requires< ReadablePropertyMapConcept<TEW1, Edge> >();
-      function_requires< ReadablePropertyMapConcept<TEW2, Edge> >();
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<TEW1, Edge> ));
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<TEW2, Edge> ));
 
       if(pcc == 0) {
           return detail::mcr_howard<FT,TG, TVIM, TEW1, TEW2>(
Index: boost/graph/breadth_first_search.hpp
===================================================================
--- boost/graph/breadth_first_search.hpp	(Revision 76000)
+++ boost/graph/breadth_first_search.hpp	(Arbeitskopie)
@@ -24,6 +24,7 @@
 #include <boost/graph/overloading.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/two_bit_color_map.hpp>
+#include <boost/concept/assert.hpp>
 
 #ifdef BOOST_GRAPH_USE_MPI
 #include <boost/graph/distributed/concepts.hpp>
@@ -34,7 +35,7 @@
   template <class Visitor, class Graph>
   struct BFSVisitorConcept {
     void constraints() {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.initialize_vertex(u, g);
       vis.discover_vertex(u, g);
       vis.examine_vertex(u, g);
@@ -59,12 +60,12 @@
      typename graph_traits<IncidenceGraph>::vertex_descriptor s,
      Buffer& Q, BFSVisitor vis, ColorMap color)
   {
-    function_requires< IncidenceGraphConcept<IncidenceGraph> >();
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
     typedef graph_traits<IncidenceGraph> GTraits;
     typedef typename GTraits::vertex_descriptor Vertex;
     typedef typename GTraits::edge_descriptor Edge;
-    function_requires< BFSVisitorConcept<BFSVisitor, IncidenceGraph> >();
-    function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
+    BOOST_CONCEPT_ASSERT(( BFSVisitorConcept<BFSVisitor, IncidenceGraph> ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
     typedef typename property_traits<ColorMap>::value_type ColorValue;
     typedef color_traits<ColorValue> Color;
     typename GTraits::out_edge_iterator ei, ei_end;
Index: boost/graph/neighbor_bfs.hpp
===================================================================
--- boost/graph/neighbor_bfs.hpp	(Revision 76000)
+++ boost/graph/neighbor_bfs.hpp	(Arbeitskopie)
@@ -24,13 +24,14 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/visitors.hpp>
 #include <boost/graph/named_function_params.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
   template <class Visitor, class Graph>
   struct NeighborBFSVisitorConcept {
     void constraints() {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.initialize_vertex(u, g);
       vis.discover_vertex(u, g);
       vis.examine_vertex(u, g);
@@ -133,13 +134,13 @@
        Buffer& Q, BFSVisitor vis, ColorMap color)
 
     {
-      function_requires< BidirectionalGraphConcept<BidirectionalGraph> >();
+      BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<BidirectionalGraph> ));
       typedef graph_traits<BidirectionalGraph> GTraits;
       typedef typename GTraits::vertex_descriptor Vertex;
       typedef typename GTraits::edge_descriptor Edge;
-      function_requires< 
-        NeighborBFSVisitorConcept<BFSVisitor, BidirectionalGraph> >();
-      function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( 
+        NeighborBFSVisitorConcept<BFSVisitor, BidirectionalGraph> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
       typedef typename property_traits<ColorMap>::value_type ColorValue;
       typedef color_traits<ColorValue> Color;
       
Index: libs/graph/test/test_construction.hpp
===================================================================
--- libs/graph/test/test_construction.hpp	(Revision 76047)
+++ libs/graph/test/test_construction.hpp	(Arbeitskopie)
@@ -7,6 +7,7 @@
 #ifndef TEST_CONSTRUCTION_HPP
 #define TEST_CONSTRUCTION_HPP
 
+#include <boost/concept/assert.hpp>
 #include <utility>
 
 /** @name Build Graph
Index: libs/graph/test/adj_list_cc.cpp
===================================================================
--- libs/graph/test/adj_list_cc.cpp	(Revision 76047)
+++ libs/graph/test/adj_list_cc.cpp	(Arbeitskopie)
@@ -9,6 +9,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/adjacency_list.hpp>
+#include <boost/concept/assert.hpp>
 
 int main(int,char*[])
 {
@@ -21,20 +22,20 @@
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_list<vecS, vecS, bidirectionalS, 
@@ -43,21 +44,21 @@
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< BidirectionalGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_list< listS, listS, directedS, 
@@ -66,20 +67,20 @@
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires< 
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_list< listS, listS, undirectedS, 
@@ -88,20 +89,20 @@
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   // Checking adjacency_list with EdgeList=setS
   {
@@ -111,21 +112,21 @@
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< BidirectionalGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_list< setS, listS, directedS, 
@@ -134,20 +135,20 @@
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_list< setS, listS, undirectedS, 
@@ -156,105 +157,105 @@
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   // Check adjacency_list without any properties
   {
     typedef adjacency_list<vecS, vecS, directedS > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
   }
   {
     typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< BidirectionalGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
   }
   {
     typedef adjacency_list< listS, listS, directedS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
   }
   {
     typedef adjacency_list< listS, listS, undirectedS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
   }
   // Checking EdgeList=setS with no properties
   {
     typedef adjacency_list<setS, vecS, bidirectionalS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< BidirectionalGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< ReadablePropertyGraphConcept<Graph, 
-      Vertex, vertex_index_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, 
+      Vertex, vertex_index_t> ));
   }
   {
     typedef adjacency_list< setS, listS, directedS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
   }
   {
     typedef adjacency_list< setS, listS, undirectedS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
   }
   return 0;
 }
Index: libs/graph/test/graph_concepts.cpp
===================================================================
--- libs/graph/test/graph_concepts.cpp	(Revision 76047)
+++ libs/graph/test/graph_concepts.cpp	(Arbeitskopie)
@@ -8,6 +8,7 @@
 //=======================================================================
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_archetypes.hpp>
+#include <boost/concept/assert.hpp>
 
 int main(int,char*[])
 {
@@ -19,22 +20,22 @@
 
   typedef incidence_graph_archetype<Vertex, directed_tag, 
     allow_parallel_edge_tag> Graph1;
-  function_requires< IncidenceGraphConcept<Graph1> >();
+  BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph1> ));
 
   typedef adjacency_graph_archetype<Vertex, directed_tag, 
     allow_parallel_edge_tag> Graph2;
-  function_requires< AdjacencyGraphConcept<Graph2> >();
+  BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph2> ));
 
   typedef vertex_list_graph_archetype<Vertex, directed_tag, 
     allow_parallel_edge_tag> Graph3;
-  function_requires< VertexListGraphConcept<Graph3> >();
+  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph3> ));
 
-  function_requires< ColorValueConcept<color_value_archetype> >();
+  BOOST_CONCEPT_ASSERT(( ColorValueConcept<color_value_archetype> ));
 
   typedef incidence_graph_archetype<Vertex, directed_tag, allow_parallel_edge_tag> G;
   typedef property_graph_archetype<G, vertex_color_t, color_value_archetype>
     Graph4;
-  function_requires< PropertyGraphConcept<Graph4, Vertex, vertex_color_t> >();
+  BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph4, Vertex, vertex_color_t> ));
 
   return 0;
 }
Index: libs/graph/test/grid_graph_cc.cpp
===================================================================
--- libs/graph/test/grid_graph_cc.cpp	(Revision 76047)
+++ libs/graph/test/grid_graph_cc.cpp	(Arbeitskopie)
@@ -10,6 +10,7 @@
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/grid_graph.hpp>
+#include <boost/concept/assert.hpp>
 
 #define DIMENSIONS 3
 using namespace boost;
@@ -20,14 +21,14 @@
   typedef graph_traits<Graph>::vertex_descriptor Vertex;
   typedef graph_traits<Graph>::edge_descriptor Edge;
 
-  function_requires<BidirectionalGraphConcept<Graph> >();
-  function_requires<VertexListGraphConcept<Graph> >();
-  function_requires<EdgeListGraphConcept<Graph> >();
-  function_requires<IncidenceGraphConcept<Graph> >();
-  function_requires<AdjacencyGraphConcept<Graph> >();
-  function_requires<AdjacencyMatrixConcept<Graph> >();
-  function_requires<ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-  function_requires<ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> >();
+  BOOST_CONCEPT_ASSERT((BidirectionalGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((VertexListGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((EdgeListGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((IncidenceGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((AdjacencyGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((AdjacencyMatrixConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+  BOOST_CONCEPT_ASSERT((ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> ));
 
   return (0);
 }
Index: libs/graph/test/filtered_graph_cc.cpp
===================================================================
--- libs/graph/test/filtered_graph_cc.cpp	(Revision 76047)
+++ libs/graph/test/filtered_graph_cc.cpp	(Arbeitskopie)
@@ -10,6 +10,7 @@
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/filtered_graph.hpp>
+#include <boost/concept/assert.hpp>
 
 int main(int,char*[])
 {
@@ -22,12 +23,12 @@
     typedef filtered_graph<Graph, is_residual_edge<ResCapMap> > ResGraph;
     typedef graph_traits<ResGraph>::edge_descriptor Edge;
 
-    function_requires< VertexListGraphConcept<ResGraph> >();
-    function_requires< EdgeListGraphConcept<ResGraph> >();
-    function_requires< IncidenceGraphConcept<ResGraph> >();
-    function_requires< AdjacencyGraphConcept<ResGraph> >();
-    function_requires< PropertyGraphConcept<ResGraph, Edge, 
-      edge_residual_capacity_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<ResGraph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<ResGraph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<ResGraph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<ResGraph> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<ResGraph, Edge, 
+      edge_residual_capacity_t> ));
   }
   // Check filtered_graph with bidirectional adjacency_list
   {
@@ -35,7 +36,7 @@
       no_property, property<edge_residual_capacity_t, long> > Graph;
     typedef property_map<Graph, edge_residual_capacity_t>::type ResCapMap;
     typedef filtered_graph<Graph, is_residual_edge<ResCapMap> > ResGraph;
-    function_requires< BidirectionalGraphConcept<ResGraph> >();
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<ResGraph> ));
   }
   return 0;
 }
Index: libs/graph/test/vector_graph_cc.cpp
===================================================================
--- libs/graph/test/vector_graph_cc.cpp	(Revision 76047)
+++ libs/graph/test/vector_graph_cc.cpp	(Arbeitskopie)
@@ -7,6 +7,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //=======================================================================
 #include <boost/config.hpp>
+#include <boost/concept/assert.hpp>
 #include <vector>
 #include <list>
 
@@ -24,9 +25,9 @@
   // Check "vector as graph"
   {
     typedef std::vector< std::list<int> > Graph;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
   }
   return 0;
 }
Index: libs/graph/test/test_properties.hpp
===================================================================
--- libs/graph/test/test_properties.hpp	(Revision 76047)
+++ libs/graph/test/test_properties.hpp	(Arbeitskopie)
@@ -7,6 +7,8 @@
 #ifndef TEST_PROPERTIES_HPP
 #define TEST_PROPERTIES_HPP
 
+#include <boost/concept/assert.hpp>
+
 template<typename T> T const& as_const(T& x) { return x; }
 template<typename T> void ignore(T const&) { }
 
Index: libs/graph/test/test_destruction.hpp
===================================================================
--- libs/graph/test/test_destruction.hpp	(Revision 76047)
+++ libs/graph/test/test_destruction.hpp	(Arbeitskopie)
@@ -7,6 +7,7 @@
 #ifndef TEST_DESTRUCTION_HPP
 #define TEST_DESTRUCTION_HPP
 
+#include <boost/concept/assert.hpp>
 #include <utility>
 
 /** @name Destroy Graph
@@ -36,7 +37,7 @@
 void destroy_graph(Graph& g, VertexSet const&, boost::mpl::false_, boost::mpl::true_) {
     using namespace boost;
     BOOST_CONCEPT_ASSERT((VertexListGraphConcept<Graph>));
-    // function_requires< VeretexMutableGraphConcept<Graph> >();
+    // BOOST_CONCEPT_ASSERT(( VeretexMutableGraphConcept<Graph> ));
 
     std::cout << "...destroy_labeled\n";
     // Remove the roof vertex
Index: libs/graph/test/test_direction.hpp
===================================================================
--- libs/graph/test/test_direction.hpp	(Revision 76047)
+++ libs/graph/test/test_direction.hpp	(Arbeitskopie)
@@ -9,6 +9,7 @@
 
 #include <algorithm>
 #include <boost/range.hpp>
+#include <boost/concept/assert.hpp>
 
 /** @name Test Out-Directed Graph
  * Test all graphs that have directed out edges.
Index: libs/graph/test/reverse_graph_cc.cpp
===================================================================
--- libs/graph/test/reverse_graph_cc.cpp	(Revision 76047)
+++ libs/graph/test/reverse_graph_cc.cpp	(Arbeitskopie)
@@ -10,6 +10,7 @@
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/reverse_graph.hpp>
+#include <boost/concept/assert.hpp>
 #include <string>
 
 int main(int,char*[])
@@ -23,11 +24,11 @@
       property<graph_name_t, std::string>
     > AdjList;
     typedef reverse_graph<AdjList> Graph;
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< ReadablePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires< ReadablePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
     AdjList g;
     Graph gr(g);
     get_property(gr, graph_name_t());
@@ -40,11 +41,11 @@
       property<graph_name_t, std::string>
     > AdjList;
     typedef reverse_graph<AdjList,AdjList&> Graph;
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< PropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires< PropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_weight_t> ));
     AdjList g;
     Graph gr(g);
     get_property(gr, graph_name_t());
Index: libs/graph/test/test_iteration.hpp
===================================================================
--- libs/graph/test/test_iteration.hpp	(Revision 76047)
+++ libs/graph/test/test_iteration.hpp	(Arbeitskopie)
@@ -7,6 +7,7 @@
 #ifndef TEST_ITERATION_HPP
 #define TEST_ITERATION_HPP
 
+#include <boost/concept/assert.hpp>
 #include <algorithm>
 
 /** @name Test Vertex List
Index: libs/graph/test/read_propmap.cpp
===================================================================
--- libs/graph/test/read_propmap.cpp	(Revision 76047)
+++ libs/graph/test/read_propmap.cpp	(Arbeitskopie)
@@ -6,6 +6,7 @@
 
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/adjacency_list.hpp>
+#include <boost/concept/assert.hpp>
 
 // Test contributed by Dmitry that validates a read-only property map bug
 // for bundled properties.
@@ -24,7 +25,7 @@
     typedef property_map<graph_t, double EdgeProp::*>::type WeightMap;
     typedef property_map<graph_t, double EdgeProp::*>::const_type cWeightMap;
     typedef graph_traits<graph_t>::edge_descriptor Edge;
-    function_requires<ReadablePropertyMapConcept<WeightMap, Edge> >();
-    function_requires<ReadablePropertyMapConcept<cWeightMap, Edge> >();
+    BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept<WeightMap, Edge> ));
+    BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept<cWeightMap, Edge> ));
     return 0;
 }
Index: libs/graph/test/adj_matrix_cc.cpp
===================================================================
--- libs/graph/test/adj_matrix_cc.cpp	(Revision 76047)
+++ libs/graph/test/adj_matrix_cc.cpp	(Arbeitskopie)
@@ -9,6 +9,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/adjacency_matrix.hpp>
+#include <boost/concept/assert.hpp>
 
 int main(int,char*[])
 {
@@ -16,21 +17,21 @@
   // Check adjacency_matrix without properties
   {
     typedef adjacency_matrix<directedS> Graph;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableGraphConcept<Graph> >();
-    function_requires< AdjacencyMatrixConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
   }
   {
     typedef adjacency_matrix<undirectedS> Graph;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableGraphConcept<Graph> >();
-    function_requires< AdjacencyMatrixConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
   }
   // Check adjacency_matrix with properties
   {
@@ -39,17 +40,17 @@
       property<edge_weight_t, float> > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< AdjacencyMatrixConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires< ReadablePropertyGraphConcept<Graph, 
-      Vertex, vertex_index_t> >();
-    function_requires< PropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires< PropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, 
+      Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_matrix<undirectedS, 
@@ -57,17 +58,17 @@
       property<edge_weight_t, float> > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< AdjacencyMatrixConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires< ReadablePropertyGraphConcept<Graph, 
-      Vertex, vertex_index_t> >();
-    function_requires< PropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires< PropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, 
+      Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   return 0;
 }
Index: libs/graph/test/edge_list_cc.cpp
===================================================================
--- libs/graph/test/edge_list_cc.cpp	(Revision 76047)
+++ libs/graph/test/edge_list_cc.cpp	(Arbeitskopie)
@@ -9,6 +9,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/edge_list.hpp>
+#include <boost/concept/assert.hpp>
 #include <cstddef>
 #include <iterator>
 
@@ -24,10 +25,10 @@
     
         typedef graph_traits<EdgeList>::edge_descriptor Edge;
     
-        function_requires< EdgeListGraphConcept<EdgeList> >();
+        BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<EdgeList> ));
     
-        function_requires< ReadablePropertyGraphConcept<EdgeList, Edge, 
-            edge_index_t> >();
+        BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<EdgeList, Edge, 
+            edge_index_t> ));
     }
     return 0;
 }
Index: libs/graph/test/test_graph.hpp
===================================================================
--- libs/graph/test/test_graph.hpp	(Revision 76047)
+++ libs/graph/test/test_graph.hpp	(Arbeitskopie)
@@ -20,6 +20,7 @@
 #include <utility>
 #include <vector>
 #include <boost/assert.hpp>
+#include <boost/concept/assert.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_mutability_traits.hpp>
Index: libs/graph/test/stanford_graph_cc.cpp
===================================================================
--- libs/graph/test/stanford_graph_cc.cpp	(Revision 76047)
+++ libs/graph/test/stanford_graph_cc.cpp	(Arbeitskopie)
@@ -9,6 +9,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/stanford_graph.hpp>
+#include <boost/concept/assert.hpp>
 
 int main(int,char*[])
 {
@@ -18,28 +19,28 @@
     typedef Graph* Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< PropertyGraphConcept<Graph, Edge, edge_length_t > >();
-    function_requires< 
-      PropertyGraphConcept<Graph, Vertex, u_property<Vertex> > >();
-    function_requires< 
-      PropertyGraphConcept<Graph, Edge, a_property<Vertex> > >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_length_t > ));
+    BOOST_CONCEPT_ASSERT(( 
+      PropertyGraphConcept<Graph, Vertex, u_property<Vertex> > ));
+    BOOST_CONCEPT_ASSERT(( 
+      PropertyGraphConcept<Graph, Edge, a_property<Vertex> > ));
   }
   {
     typedef const Graph* Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< 
-      ReadablePropertyGraphConcept<Graph, Edge, edge_length_t > >();
-    function_requires< 
-      ReadablePropertyGraphConcept<Graph, Vertex, u_property<Vertex> > >();
-    function_requires< 
-      ReadablePropertyGraphConcept<Graph, Edge, a_property<Vertex> > >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Edge, edge_length_t > ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, u_property<Vertex> > ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Edge, a_property<Vertex> > ));
   }
   return 0;
 }
Index: libs/graph/test/leda_graph_cc.cpp
===================================================================
--- libs/graph/test/leda_graph_cc.cpp	(Revision 76047)
+++ libs/graph/test/leda_graph_cc.cpp	(Arbeitskopie)
@@ -8,8 +8,8 @@
 //=======================================================================
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/leda_graph.hpp>
+#include <boost/concept/assert.hpp>
 
-
 int
 main(int,char*[])
 {
@@ -18,21 +18,21 @@
     typedef leda::GRAPH<int,int> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< BidirectionalGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< VertexMutableGraphConcept<Graph> >();
-    function_requires< EdgeMutableGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_all_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, edge_all_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT((
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT((
+      ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> ));
+    BOOST_CONCEPT_ASSERT((
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_all_t> ));
+    BOOST_CONCEPT_ASSERT((
+      LvaluePropertyGraphConcept<Graph, Vertex, edge_all_t> ));
   }
   return 0;
 }
Index: libs/graph/doc/transitive_closure.w
===================================================================
--- libs/graph/doc/transitive_closure.w	(Revision 75975)
+++ libs/graph/doc/transitive_closure.w	(Arbeitskopie)
@@ -160,11 +160,11 @@
 
 @d Concept checking
 @{
-function_requires< VertexListGraphConcept<Graph> >();
-function_requires< AdjacencyGraphConcept<Graph> >();
-function_requires< VertexMutableGraphConcept<GraphTC> >();
-function_requires< EdgeMutableGraphConcept<GraphTC> >();
-function_requires< ReadablePropertyMapConcept<VertexIndexMap, vertex> >();
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept<GraphTC> ));
+BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<GraphTC> ));
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<VertexIndexMap, vertex> ));
 @}
 
 \noindent To simplify the code in the rest of the function we make the
@@ -566,8 +566,8 @@
   typedef typename graph_traits<G>::vertex_descriptor vertex;
   typedef typename graph_traits<G>::vertex_iterator vertex_iterator;
 
-  function_requires< AdjacencyMatrixConcept<G> >();
-  function_requires< EdgeMutableGraphConcept<G> >();
+  BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<G> ));
+  BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<G> ));
 
   // Matrix form:
   // for k
@@ -597,8 +597,8 @@
   typedef typename graph_traits<G>::vertex_descriptor vertex;
   typedef typename graph_traits<G>::vertex_iterator vertex_iterator;
 
-  function_requires< AdjacencyMatrixConcept<G> >();
-  function_requires< EdgeMutableGraphConcept<G> >();
+  BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<G> ));
+  BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<G> ));
 
   // Make sure second loop will work  
   if (num_vertices(g) == 0)
@@ -671,6 +671,7 @@
 #include <boost/graph/topological_sort.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/named_function_params.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
Index: libs/graph/doc/BidirectionalGraph.html
===================================================================
--- libs/graph/doc/BidirectionalGraph.html	(Revision 75975)
+++ libs/graph/doc/BidirectionalGraph.html	(Arbeitskopie)
@@ -145,8 +145,8 @@
     typedef typename boost::graph_traits&lt;G&gt;::in_edge_iterator
       in_edge_iterator;
     void constraints() {
-      function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;in_edge_iterator&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;in_edge_iterator&gt; ));
 
       p = in_edges(v, g);
       e = *p.first;
Index: libs/graph/doc/AdjacencyGraph.html
===================================================================
--- libs/graph/doc/AdjacencyGraph.html	(Revision 75975)
+++ libs/graph/doc/AdjacencyGraph.html	(Arbeitskopie)
@@ -112,8 +112,8 @@
     typedef typename boost::graph_traits&lt;G&gt;::adjacency_iterator
       adjacency_iterator;
     void constraints() {
-      function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;adjacency_iterator&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;adjacency_iterator&gt; ));
 
       p = adjacent_vertices(v, g);
       v = *p.first;
Index: libs/graph/doc/IncidenceGraph.html
===================================================================
--- libs/graph/doc/IncidenceGraph.html	(Revision 75975)
+++ libs/graph/doc/IncidenceGraph.html	(Arbeitskopie)
@@ -162,8 +162,8 @@
   {
     typedef typename boost::graph_traits&lt;G&gt;::out_edge_iterator out_edge_iterator;
     void constraints() {
-      function_requires&lt; GraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;out_edge_iterator&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;out_edge_iterator&gt; ));
 
       p = out_edges(u, g);
       e = *p.first;
Index: libs/graph/doc/MutablePropertyGraph.html
===================================================================
--- libs/graph/doc/MutablePropertyGraph.html	(Revision 75975)
+++ libs/graph/doc/MutablePropertyGraph.html	(Arbeitskopie)
@@ -125,7 +125,7 @@
   {
     typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
     void constraints() {
-      function_requires&lt; MutableGraphConcept&lt;G&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( MutableGraphConcept&lt;G&gt; ));
       v = add_vertex(vp, g);
       p = add_edge(u, v, ep, g);
     }
Index: libs/graph/doc/AStarHeuristic.html
===================================================================
--- libs/graph/doc/AStarHeuristic.html	(Revision 75975)
+++ libs/graph/doc/AStarHeuristic.html	(Arbeitskopie)
@@ -116,7 +116,7 @@
   struct AStarHeuristicConcept {
     void constraints()
     {
-      function_requires&lt; CopyConstructibleConcept&lt;Heuristic&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept&lt;Heuristic&gt; ));
       h(u);
     }
     Heuristic h;
Index: libs/graph/doc/isomorphism-impl-v2.w
===================================================================
--- libs/graph/doc/isomorphism-impl-v2.w	(Revision 75975)
+++ libs/graph/doc/isomorphism-impl-v2.w	(Arbeitskopie)
@@ -388,31 +388,31 @@
 @d Concept checking
 @{
 // Graph requirements
-function_requires< VertexListGraphConcept<Graph1> >();
-function_requires< EdgeListGraphConcept<Graph1> >();
-function_requires< VertexListGraphConcept<Graph2> >();
-function_requires< BidirectionalGraphConcept<Graph2> >();
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
+BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
 
 typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_t;
 typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
 typedef typename graph_traits<Graph1>::vertices_size_type size_type;
 
 // Vertex invariant requirement
-function_requires< AdaptableUnaryFunctionConcept<Invariant1,
-  size_type, vertex1_t> >();
-function_requires< AdaptableUnaryFunctionConcept<Invariant2,
-  size_type, vertex2_t> >();
+BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant1,
+  size_type, vertex1_t> ));
+BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant2,
+  size_type, vertex2_t> ));
 
 // Property map requirements
-function_requires< ReadWritePropertyMapConcept<IsoMapping, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IsoMapping, vertex1_t> ));
 typedef typename property_traits<IsoMapping>::value_type IsoMappingValue;
 BOOST_STATIC_ASSERT((is_same<IsoMappingValue, vertex2_t>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
 typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
 typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
 @}
Index: libs/graph/doc/Graph.html
===================================================================
--- libs/graph/doc/Graph.html	(Revision 75975)
+++ libs/graph/doc/Graph.html	(Arbeitskopie)
@@ -121,12 +121,12 @@
     typedef typename boost::graph_traits&lt;G&gt;::traversal_category traversal_category;
 
     void constraints() {
-      function_requires&lt; DefaultConstructibleConcept&lt;vertex_descriptor&gt; &gt;();
-      function_requires&lt; EqualityComparableConcept&lt;vertex_descriptor&gt; &gt;();
-      function_requires&lt; AssignableConcept&lt;vertex_descriptor&gt; &gt;();
-      function_requires&lt; DefaultConstructibleConcept&lt;edge_descriptor&gt; &gt;();
-      function_requires&lt; EqualityComparableConcept&lt;edge_descriptor&gt; &gt;();
-      function_requires&lt; AssignableConcept&lt;edge_descriptor&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( DefaultConstructibleConcept&lt;vertex_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( EqualityComparableConcept&lt;vertex_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( AssignableConcept&lt;vertex_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( DefaultConstructibleConcept&lt;edge_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( EqualityComparableConcept&lt;edge_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( AssignableConcept&lt;edge_descriptor&gt; ));
     }
     G g;
   };
Index: libs/graph/doc/leda_conversion.html
===================================================================
--- libs/graph/doc/leda_conversion.html	(Revision 75975)
+++ libs/graph/doc/leda_conversion.html	(Arbeitskopie)
@@ -236,9 +236,9 @@
   main(int,char*[])
   {
     typedef GRAPH&lt;int,int&gt; Graph;
-    function_requires&lt; VertexListGraphConcept&lt;Graph&gt; &gt;();
-    function_requires&lt; BidirectionalGraphConcept&lt;Graph&gt; &gt;();
-    function_requires&lt; MutableGraphConcept&lt;Graph&gt; &gt;();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;Graph&gt; ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept&lt;Graph&gt; ));
+    BOOST_CONCEPT_ASSERT(( MutableGraphConcept&lt;Graph&gt; ));
     return 0;
   }
 </PRE>
Index: libs/graph/doc/isomorphism-impl-v3.w
===================================================================
--- libs/graph/doc/isomorphism-impl-v3.w	(Revision 75975)
+++ libs/graph/doc/isomorphism-impl-v3.w	(Arbeitskopie)
@@ -507,31 +507,31 @@
 @d Concept checking
 @{
 // Graph requirements
-function_requires< VertexListGraphConcept<Graph1> >();
-function_requires< EdgeListGraphConcept<Graph1> >();
-function_requires< VertexListGraphConcept<Graph2> >();
-function_requires< BidirectionalGraphConcept<Graph2> >();
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
+BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
 
 typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_t;
 typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
 typedef typename graph_traits<Graph1>::vertices_size_type size_type;
 
 // Vertex invariant requirement
-function_requires< AdaptableUnaryFunctionConcept<Invariant1,
-  size_type, vertex1_t> >();
-function_requires< AdaptableUnaryFunctionConcept<Invariant2,
-  size_type, vertex2_t> >();
+BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant1,
+  size_type, vertex1_t> ));
+BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant2,
+  size_type, vertex2_t> ));
 
 // Property map requirements
-function_requires< ReadWritePropertyMapConcept<IsoMapping, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IsoMapping, vertex1_t> ));
 typedef typename property_traits<IsoMapping>::value_type IsoMappingValue;
 BOOST_STATIC_ASSERT((is_same<IsoMappingValue, vertex2_t>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
 typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
 typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
 @}
Index: libs/graph/doc/biconnected_components.w
===================================================================
--- libs/graph/doc/biconnected_components.w	(Revision 75975)
+++ libs/graph/doc/biconnected_components.w	(Arbeitskopie)
@@ -156,11 +156,11 @@
 
 @d Concept checking of type parameters
 @{
-function_requires< VertexListGraphConcept<Graph> >();
-function_requires< IncidenceGraphConcept<Graph> >();
-function_requires< WritablePropertyMapConcept<ComponentMap, edge_t> >();
-function_requires< ReadWritePropertyMapConcept<DiscoverTimeMap, vertex_t> >();
-function_requires< ReadWritePropertyMapConcept<LowPointMap, vertex_t> >();
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, edge_t> ));
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DiscoverTimeMap, vertex_t> ));
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<LowPointMap, vertex_t> ));
 @}
 
 The first step of the algorithm is to initialize the discover times of
@@ -286,6 +286,7 @@
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/property_map/property_map.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
   @<Biconnected Components Algorithm@>
Index: libs/graph/doc/VertexListGraph.html
===================================================================
--- libs/graph/doc/VertexListGraph.html	(Revision 75975)
+++ libs/graph/doc/VertexListGraph.html	(Arbeitskopie)
@@ -121,9 +121,9 @@
     typedef typename boost::graph_traits&lt;G&gt;::vertex_iterator 
       vertex_iterator;
     void constraints() {
-      function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; AdjacencyGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;vertex_iterator&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;vertex_iterator&gt; ));
 
       p = vertices(g);
       V = num_vertices(g);
Index: libs/graph/doc/VertexAndEdgeListGraph.html
===================================================================
--- libs/graph/doc/VertexAndEdgeListGraph.html	(Revision 75975)
+++ libs/graph/doc/VertexAndEdgeListGraph.html	(Arbeitskopie)
@@ -51,8 +51,8 @@
   struct VertexAndEdgeListGraphConcept
   {
     void constraints() {
-      function_requires&lt; VertexListGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; EdgeListGraphConcept&lt;G&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept&lt;G&gt; ));
     }
   };
 </PRE>
Index: libs/graph/doc/PropertyGraph.html
===================================================================
--- libs/graph/doc/PropertyGraph.html	(Revision 75975)
+++ libs/graph/doc/PropertyGraph.html	(Arbeitskopie)
@@ -173,9 +173,9 @@
     typedef typename property_map&lt;G, PropertyTag&gt;::type Map;
     typedef typename property_map&lt;G, PropertyTag&gt;::const_type const_Map;
     void constraints() {
-      function_requires&lt; GraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; ReadWritePropertyMapConcept&lt;Map, X&gt; &gt;();
-      function_requires&lt; ReadablePropertyMapConcept&lt;const_Map, X&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept&lt;Map, X&gt; ));
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept&lt;const_Map, X&gt; ));
 
       Map pmap = get(PropertyTag(), g);
       pval = get(PropertyTag(), g, x);
Index: libs/graph/doc/isomorphism-impl.w
===================================================================
--- libs/graph/doc/isomorphism-impl.w	(Revision 75975)
+++ libs/graph/doc/isomorphism-impl.w	(Arbeitskopie)
@@ -301,21 +301,21 @@
 @d Concept checking
 @{
 // Graph requirements
-function_requires< VertexListGraphConcept<Graph1> >();
-function_requires< EdgeListGraphConcept<Graph1> >();
-function_requires< VertexListGraphConcept<Graph2> >();
-function_requires< BidirectionalGraphConcept<Graph2> >();
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
+BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
 
 // Property map requirements
-function_requires< ReadWritePropertyMapConcept<IndexMapping, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IndexMapping, vertex1_t> ));
 typedef typename property_traits<IndexMapping>::value_type IndexMappingValue;
 BOOST_STATIC_ASSERT((is_same<IndexMappingValue, vertex2_t>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
 typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
 typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
 @}
Index: libs/graph/doc/MutableGraph.html
===================================================================
--- libs/graph/doc/MutableGraph.html	(Revision 75975)
+++ libs/graph/doc/MutableGraph.html	(Arbeitskopie)
@@ -250,7 +250,7 @@
   struct MutableIncidenceGraphConcept
   {
     void constraints() {
-      function_requires&lt; MutableGraph&lt;G&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( MutableGraph&lt;G&gt; ));
       remove_edge(iter, g);
       remove_out_edge_if(u, p, g);
     }
@@ -265,7 +265,7 @@
   struct MutableBidirectionalGraphConcept
   {
     void constraints() {
-      function_requires&lt; MutableIncidenceGraph&lt;G&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( MutableIncidenceGraph&lt;G&gt; ));
       remove_in_edge_if(u, p, g);
     }
     G g;
@@ -278,7 +278,7 @@
   struct MutableEdgeListGraphConcept
   {
     void constraints() {
-      function_requires&lt; MutableGraph&lt;G&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( MutableGraph&lt;G&gt; ));
       remove_edge_if(p, g);
     }
     G g;
Index: libs/graph/doc/constructing_algorithms.html
===================================================================
--- libs/graph/doc/constructing_algorithms.html	(Revision 75975)
+++ libs/graph/doc/constructing_algorithms.html	(Arbeitskopie)
@@ -79,7 +79,7 @@
 href="./VertexListGraph.html">VertexListGraph</a>. This is enforced by
 the use of those graph operations in the algorithm, and furthermore by
 our explicit requirement added as a concept check with
-<TT>function_requires()</TT> (see Section <A
+<TT>BOOST_CONCEPT_ASSERT()</TT> (see Section <A
 HREF="../../concept_check/concept_check.htm">Concept
 Checking</A> for more details about concept checking).
 
@@ -122,10 +122,10 @@
     typedef typename property_traits&lt;Color&gt;::value_type ColorType;
     typedef typename property_traits&lt;Order&gt;::value_type OrderType;
 
-    function_requires&lt; VertexListGraphConcept&lt;VertexListGraph&gt; &gt;();
-    function_requires&lt; ReadWritePropertyMapConcept&lt;Color, vertex_descriptor&gt; &gt;();
-    function_requires&lt; IntegerConcept&lt;ColorType&gt; &gt;();
-    function_requires&lt; ReadablePropertyMapConcept&lt;Order, size_type&gt; &gt;();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;VertexListGraph&gt; ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept&lt;Color, vertex_descriptor&gt; ));
+    BOOST_CONCEPT_ASSERT(( IntegerConcept&lt;ColorType&gt; ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept&lt;Order, size_type&gt; ));
     BOOST_STATIC_ASSERT((is_same&lt;OrderType, vertex_descriptor&gt;::value));
     
     size_type max_color = 0;
Index: libs/graph/doc/EdgeListGraph.html
===================================================================
--- libs/graph/doc/EdgeListGraph.html	(Revision 75975)
+++ libs/graph/doc/EdgeListGraph.html	(Arbeitskopie)
@@ -146,8 +146,8 @@
     typedef typename boost::graph_traits&lt;G&gt;::edge_iterator 
       edge_iterator;
     void constraints() {
-      function_requires&lt; GraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;edge_iterator&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;edge_iterator&gt; ));
 
       p = edges(g);
       E = num_edges(g);
Index: libs/graph/doc/KeyedUpdatableQueue.html
===================================================================
--- libs/graph/doc/KeyedUpdatableQueue.html	(Revision 75975)
+++ libs/graph/doc/KeyedUpdatableQueue.html	(Arbeitskopie)
@@ -63,8 +63,8 @@
     typedef typename Q::key_map key_map;
     
     void constraints() {
-      function_requires&lt; UpdatableQueue&lt;Q&gt; &gt;();
-      function_requires&lt; ReadWritePropertyMap&lt; key_map, typename Buffer&lt;Q&gt;::value_type &gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( UpdatableQueue&lt;Q&gt; ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMap&lt; key_map, typename Buffer&lt;Q&gt;::value_type &gt; ));
     }
     
     void const_constraints(const Q&amp; cq) {
Index: libs/graph/doc/UpdatableQueue.html
===================================================================
--- libs/graph/doc/UpdatableQueue.html	(Revision 75975)
+++ libs/graph/doc/UpdatableQueue.html	(Arbeitskopie)
@@ -58,7 +58,7 @@
   struct UpdatableQueueConcept
   {
     void constraints() {
-      function_requires&lt; Buffer&lt;Q&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( Buffer&lt;Q&gt; ));
       
       q.update(g_ct);
     }
Index: libs/graph/example/implicit_graph.cpp
===================================================================
--- libs/graph/example/implicit_graph.cpp	(Revision 75975)
+++ libs/graph/example/implicit_graph.cpp	(Arbeitskopie)
@@ -4,7 +4,7 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-
+#include <boost/concept/assert.hpp>
 #include <boost/graph/adjacency_iterator.hpp>
 #include <boost/graph/dijkstra_shortest_paths.hpp>
 #include <boost/graph/graph_concepts.hpp>
@@ -444,15 +444,15 @@
   // Check the concepts that graph models.  This is included to demonstrate
   // how concept checking works, but is not required for a working program
   // since Boost algorithms do their own concept checking.
-  function_requires< BidirectionalGraphConcept<ring_graph> >();
-  function_requires< AdjacencyGraphConcept<ring_graph> >();
-  function_requires< VertexListGraphConcept<ring_graph> >();
-  function_requires< EdgeListGraphConcept<ring_graph> >();
-  function_requires< AdjacencyMatrixConcept<ring_graph> >();
-  function_requires<
-    ReadablePropertyMapConcept<const_edge_weight_map, edge_descriptor> >();
-  function_requires<
-    ReadablePropertyGraphConcept<ring_graph, edge_descriptor, edge_weight_t> >();
+  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<ring_graph> ));
+  BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<ring_graph> ));
+  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<ring_graph> ));
+  BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<ring_graph> ));
+  BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<ring_graph> ));
+  BOOST_CONCEPT_ASSERT((
+    ReadablePropertyMapConcept<const_edge_weight_map, edge_descriptor> ));
+  BOOST_CONCEPT_ASSERT((
+    ReadablePropertyGraphConcept<ring_graph, edge_descriptor, edge_weight_t> ));
 
   // Specify the size of the graph on the command line, or use a default size
   // of 5.
Index: libs/graph/example/put-get-helper-eg.cpp
===================================================================
--- libs/graph/example/put-get-helper-eg.cpp	(Revision 75975)
+++ libs/graph/example/put-get-helper-eg.cpp	(Arbeitskopie)
@@ -8,6 +8,7 @@
 #include <vector>
 #include <string>
 #include <boost/property_map/property_map.hpp>
+#include <boost/concept/assert.hpp>
 
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
 #error This examples requires a compiler that provides a working std::iterator_traits
@@ -53,6 +54,6 @@
   typedef foo::iterator_property_map < vec_t::iterator,
     boost::identity_property_map > pmap_t;
   using namespace boost;
-  function_requires < Mutable_LvaluePropertyMapConcept < pmap_t, int > >();
+  BOOST_CONCEPT_ASSERT(( Mutable_LvaluePropertyMapConcept<pmap_t, int> ));
   return 0;
 }
Index: libs/graph/example/loops_dfs.cpp
===================================================================
--- libs/graph/example/loops_dfs.cpp	(Revision 75975)
+++ libs/graph/example/loops_dfs.cpp	(Arbeitskopie)
@@ -6,6 +6,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //=======================================================================
 #include <boost/config.hpp>
+#include <boost/concept/assert.hpp>
 #include <iostream>
 #include <fstream>
 #include <stack>
@@ -47,7 +48,7 @@
            const Graph & g, 
            Loops & loops)    // A container of sets of vertices
 {
-  function_requires < BidirectionalGraphConcept < Graph > >();
+  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
   typedef typename graph_traits < Graph >::edge_descriptor Edge;
   typedef typename graph_traits < Graph >::vertex_descriptor Vertex;
   std::vector < Edge > back_edges;
@@ -69,7 +70,7 @@
                     Graph >::edge_descriptor back_edge, const Graph & g,
                     Set & loop_set)
 {
-  function_requires < BidirectionalGraphConcept < Graph > >();
+  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
   typedef typename graph_traits < Graph >::vertex_descriptor Vertex;
   typedef color_traits < default_color_type > Color;
 
Index: libs/graph/example/leda-concept-check.cpp
===================================================================
--- libs/graph/example/leda-concept-check.cpp	(Revision 75975)
+++ libs/graph/example/leda-concept-check.cpp	(Arbeitskopie)
@@ -7,15 +7,16 @@
 //=======================================================================
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/leda_graph.hpp>
+#include <boost/concept/assert.hpp>
 
 int
 main()
 {
   using namespace boost;
-  typedef leda::GRAPH < int, int >Graph;
-  function_requires < VertexListGraphConcept < Graph > >();
-  function_requires < BidirectionalGraphConcept < Graph > >();
-  function_requires < VertexMutableGraphConcept < Graph > >();
-  function_requires < EdgeMutableGraphConcept < Graph > >();
+  typedef leda::GRAPH<int, int> Graph;
+  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept< Graph> ));
+  BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept< Graph> ));
+  BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<Graph> ));
   return EXIT_SUCCESS;
 }
Index: libs/concept_check/reference.htm
===================================================================
--- libs/concept_check/reference.htm	(Revision 75975)
+++ libs/concept_check/reference.htm	(Arbeitskopie)
@@ -366,6 +366,12 @@
 void function_requires();
 </pre>
 
+  <p><code>function_requires()</code> has been deprecated in favor of <code>BOOST_CONCEPT_ASSERT</code>.
+   This means that <del><code>function_requires< Concept<Type> >();</code></del>
+   becomes <code>BOOST_CONCEPT_ASSERT((Concept<Type>));</code>
+   (don't forget to <code>#include &quot;boost/concept/assert.hpp&quot;</code>).
+
+
   <h3><a name="deprecated-macros" id="deprecated-macros">Deprecated
   Macros</a></h3>
   <pre>