Ticket #6293: graph-library-boost-concept-assert.patch

File graph-library-boost-concept-assert.patch, 133.3 KB (added by ich@…, 11 years ago)

replaces function_requires by BOOST_CONCEPT_ASSERT

  • boost/graph/clustering_coefficient.hpp

     
    1111#include <boost/graph/graph_traits.hpp>
    1212#include <boost/graph/graph_concepts.hpp>
    1313#include <boost/graph/lookup_edge.hpp>
     14#include <boost/concept/assert.hpp>
    1415
    1516namespace boost
    1617{
    … …  
    2021    inline typename graph_traits<Graph>::degree_size_type
    2122    possible_edges(const Graph& g, std::size_t k, directed_tag)
    2223    {
    23         function_requires< GraphConcept<Graph> >();
     24        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
    2425        typedef typename graph_traits<Graph>::degree_size_type T;
    2526        return T(k) * (T(k) - 1);
    2627    }
    … …  
    4243                directed_tag)
    4344
    4445    {
    45         function_requires< AdjacencyMatrixConcept<Graph> >();
     46        BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
    4647        return (lookup_edge(u, v, g).second ? 1 : 0) +
    4748                (lookup_edge(v, u, g).second ? 1 : 0);
    4849    }
    … …  
    5556                typename graph_traits<Graph>::vertex_descriptor v,
    5657                undirected_tag)
    5758    {
    58         function_requires< AdjacencyMatrixConcept<Graph> >();
     59        BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
    5960        return lookup_edge(u, v, g).second ? 1 : 0;
    6061    }
    6162}
    … …  
    6465inline typename graph_traits<Graph>::degree_size_type
    6566num_paths_through_vertex(const Graph& g, Vertex v)
    6667{
    67     function_requires< AdjacencyGraphConcept<Graph> >();
     68    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
    6869    typedef typename graph_traits<Graph>::directed_category Directed;
    6970    typedef typename graph_traits<Graph>::adjacency_iterator AdjacencyIterator;
    7071
    … …  
    8182inline typename graph_traits<Graph>::degree_size_type
    8283num_triangles_on_vertex(const Graph& g, Vertex v)
    8384{
    84     function_requires< IncidenceGraphConcept<Graph> >();
    85     function_requires< AdjacencyGraphConcept<Graph> >();
     85    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     86    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
    8687    typedef typename graph_traits<Graph>::degree_size_type Degree;
    8788    typedef typename graph_traits<Graph>::directed_category Directed;
    8889    typedef typename graph_traits<Graph>::adjacency_iterator AdjacencyIterator;
    … …  
    119120inline typename property_traits<ClusteringMap>::value_type
    120121all_clustering_coefficients(const Graph& g, ClusteringMap cm)
    121122{
    122     function_requires< VertexListGraphConcept<Graph> >();
     123    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    123124    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    124125    typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
    125     function_requires< WritablePropertyMapConcept<ClusteringMap,Vertex> >();
     126    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ClusteringMap,Vertex> ));
    126127    typedef typename property_traits<ClusteringMap>::value_type Coefficient;
    127128
    128129    Coefficient sum(0);
    … …  
    139140inline typename property_traits<ClusteringMap>::value_type
    140141mean_clustering_coefficient(const Graph& g, ClusteringMap cm)
    141142{
    142     function_requires< VertexListGraphConcept<Graph> >();
     143    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    143144    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    144145    typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
    145     function_requires< ReadablePropertyMapConcept<ClusteringMap,Vertex> >();
     146    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<ClusteringMap,Vertex> ));
    146147    typedef typename property_traits<ClusteringMap>::value_type Coefficient;
    147148
    148149    Coefficient cc(0);

  • boost/graph/bellman_ford_shortest_paths.hpp

     
    2929#include <boost/graph/relax.hpp>
    3030#include <boost/graph/visitors.hpp>
    3131#include <boost/graph/named_function_params.hpp>
     32#include <boost/concept/assert.hpp>
    3233
    3334namespace boost {
    3435
    3536  template <class Visitor, class Graph>
    3637  struct BellmanFordVisitorConcept {
    3738    void constraints() {
    38       function_requires< CopyConstructibleConcept<Visitor> >();
     39      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
    3940      vis.examine_edge(e, g);
    4041      vis.edge_relaxed(e, g);
    4142      vis.edge_not_relaxed(e, g);
    … …  
    9596                         BinaryPredicate compare,
    9697                         BellmanFordVisitor v)
    9798  {
    98     function_requires<EdgeListGraphConcept<EdgeListGraph> >();
     99    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<EdgeListGraph> ));
    99100    typedef graph_traits<EdgeListGraph> GTraits;
    100101    typedef typename GTraits::edge_descriptor Edge;
    101102    typedef typename GTraits::vertex_descriptor Vertex;
    102     function_requires<ReadWritePropertyMapConcept<DistanceMap, Vertex> >();
    103     function_requires<ReadablePropertyMapConcept<WeightMap, Edge> >();
     103    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DistanceMap, Vertex> ));
     104    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<WeightMap, Edge> ));
    104105    typedef typename property_traits<DistanceMap>::value_type D_value;
    105106    typedef typename property_traits<WeightMap>::value_type W_value;
    106107
    … …  
    229230    (VertexAndEdgeListGraph& g,
    230231     const bgl_named_params<P, T, R>& params)
    231232  {               
    232     function_requires<VertexListGraphConcept<VertexAndEdgeListGraph> >();
     233    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<VertexAndEdgeListGraph> ));
    233234    return detail::bellman_dispatch
    234235      (g, num_vertices(g),
    235236       choose_const_pmap(get_param(params, edge_weight), g, edge_weight),

  • boost/graph/bron_kerbosch_all_cliques.hpp

     
    1111#include <deque>
    1212#include <boost/config.hpp>
    1313
     14#include <boost/concept/assert.hpp>
     15
    1416#include <boost/graph/graph_concepts.hpp>
    1517#include <boost/graph/lookup_edge.hpp>
    1618
    … …  
    151153                                const Container& in,
    152154                                Container& out)
    153155    {
    154         function_requires< GraphConcept<Graph> >();
     156        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
    155157
    156158        typename graph_traits<Graph>::directed_category cat;
    157159        typename Container::const_iterator i, end = in.end();
    … …  
    174176                        Visitor vis,
    175177                        std::size_t min)
    176178    {
    177         function_requires< GraphConcept<Graph> >();
    178         function_requires< CliqueVisitorConcept<Visitor,Clique,Graph> >();
     179        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     180        BOOST_CONCEPT_ASSERT(( CliqueVisitorConcept<Visitor,Clique,Graph> ));
    179181        typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    180182
    181183        // Is there vertex in nots that is connected to all vertices
    … …  
    266268inline void
    267269bron_kerbosch_all_cliques(const Graph& g, Visitor vis, std::size_t min)
    268270{
    269     function_requires< IncidenceGraphConcept<Graph> >();
    270     function_requires< VertexListGraphConcept<Graph> >();
    271     function_requires< VertexIndexGraphConcept<Graph> >();
    272     function_requires< AdjacencyMatrixConcept<Graph> >(); // Structural requirement only
     271    BOOST_CONCEPT_ASSERT< IncidenceGraphConcept<Graph> ));
     272    BOOST_CONCEPT_ASSERT< VertexListGraphConcept<Graph> ));
     273    BOOST_CONCEPT_ASSERT< VertexIndexGraphConcept<Graph> ));
     274    BOOST_CONCEPT_ASSERT< AdjacencyMatrixConcept<Graph> )); // Structural requirement only
    273275    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    274276    typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
    275277    typedef std::vector<Vertex> VertexSet;
    276278    typedef std::deque<Vertex> Clique;
    277     function_requires< CliqueVisitorConcept<Visitor,Clique,Graph> >();
     279    BOOST_CONCEPT_ASSERT< CliqueVisitorConcept<Visitor,Clique,Graph> ));
    278280
    279281    // NOTE: We're using a deque to implement the clique, because it provides
    280282    // constant inserts and removals at the end and also a constant size.

  • boost/graph/undirected_dfs.hpp

     
    1313
    1414#include <boost/graph/depth_first_search.hpp>
    1515#include <vector>
     16#include <boost/concept/assert.hpp>
    1617
    1718namespace boost {
    1819
    … …  
    3233       VertexColorMap vertex_color,
    3334       EdgeColorMap edge_color)
    3435    {
    35       function_requires<IncidenceGraphConcept<IncidenceGraph> >();
    36       function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
     36      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
     37      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
    3738      typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
    3839      typedef typename graph_traits<IncidenceGraph>::edge_descriptor Edge;
    39       function_requires<ReadWritePropertyMapConcept<VertexColorMap,Vertex> >();
    40       function_requires<ReadWritePropertyMapConcept<EdgeColorMap,Edge> >();
     40      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<VertexColorMap,Vertex> ));
     41      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<EdgeColorMap,Edge> ));
    4142      typedef typename property_traits<VertexColorMap>::value_type ColorValue;
    4243      typedef typename property_traits<EdgeColorMap>::value_type EColorValue;
    43       function_requires< ColorValueConcept<ColorValue> >();
    44       function_requires< ColorValueConcept<EColorValue> >();
     44      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
     45      BOOST_CONCEPT_ASSERT(( ColorValueConcept<EColorValue> ));
    4546      typedef color_traits<ColorValue> Color;
    4647      typedef color_traits<EColorValue> EColor;
    4748      typedef typename graph_traits<IncidenceGraph>::out_edge_iterator Iter;
    … …  
    9495       VertexColorMap vertex_color,
    9596       EdgeColorMap edge_color)
    9697    {
    97       function_requires<IncidenceGraphConcept<IncidenceGraph> >();
    98       function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
     98      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
     99      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
    99100      typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
    100101      typedef typename graph_traits<IncidenceGraph>::edge_descriptor Edge;
    101       function_requires<ReadWritePropertyMapConcept<VertexColorMap,Vertex> >();
    102       function_requires<ReadWritePropertyMapConcept<EdgeColorMap,Edge> >();
     102      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<VertexColorMap,Vertex> ));
     103      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<EdgeColorMap,Edge> ));
    103104      typedef typename property_traits<VertexColorMap>::value_type ColorValue;
    104105      typedef typename property_traits<EdgeColorMap>::value_type EColorValue;
    105       function_requires< ColorValueConcept<ColorValue> >();
    106       function_requires< ColorValueConcept<EColorValue> >();
     106      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
     107      BOOST_CONCEPT_ASSERT(( ColorValueConcept<EColorValue> ));
    107108      typedef color_traits<ColorValue> Color;
    108109      typedef color_traits<EColorValue> EColor;
    109110      typename graph_traits<IncidenceGraph>::out_edge_iterator ei, ei_end;
    … …  
    134135                 VertexColorMap vertex_color, EdgeColorMap edge_color,
    135136                 Vertex start_vertex)
    136137  {
    137     function_requires<DFSVisitorConcept<DFSVisitor, Graph> >();
    138       function_requires<EdgeListGraphConcept<Graph> >();
     138    BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, Graph> ));
     139    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
    139140
    140141    typedef typename property_traits<VertexColorMap>::value_type ColorValue;
    141142    typedef color_traits<ColorValue> Color;

  • boost/graph/boykov_kolmogorov_max_flow.hpp

     
    4747#include <boost/graph/graph_concepts.hpp>
    4848#include <boost/graph/named_function_params.hpp>
    4949#include <boost/graph/lookup_edge.hpp>
     50#include <boost/concept/assert.hpp>
    5051
    5152// The algorithm impelemented here is described in:
    5253//
    … …  
    743744  typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
    744745
    745746  //as this method is the last one before we instantiate the solver, we do the concept checks here
    746   function_requires<VertexListGraphConcept<Graph> >(); //to have vertices(), num_vertices(),
    747   function_requires<EdgeListGraphConcept<Graph> >(); //to have edges()
    748   function_requires<IncidenceGraphConcept<Graph> >(); //to have source(), target() and out_edges()
    749   function_requires<ReadablePropertyMapConcept<CapacityEdgeMap, edge_descriptor> >(); //read flow-values from edges
    750   function_requires<ReadWritePropertyMapConcept<ResidualCapacityEdgeMap, edge_descriptor> >(); //write flow-values to residuals
    751   function_requires<ReadablePropertyMapConcept<ReverseEdgeMap, edge_descriptor> >(); //read out reverse edges
    752   function_requires<ReadWritePropertyMapConcept<PredecessorMap, vertex_descriptor> >(); //store predecessor there
    753   function_requires<ReadWritePropertyMapConcept<ColorMap, vertex_descriptor> >(); //write corresponding tree
    754   function_requires<ReadWritePropertyMapConcept<DistanceMap, vertex_descriptor> >(); //write distance to source/sink
    755   function_requires<ReadablePropertyMapConcept<IndexMap, vertex_descriptor> >(); //get index 0...|V|-1
     747  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> )); //to have vertices(), num_vertices(),
     748  BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> )); //to have edges()
     749  BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> )); //to have source(), target() and out_edges()
     750  BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<CapacityEdgeMap, edge_descriptor> )); //read flow-values from edges
     751  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ResidualCapacityEdgeMap, edge_descriptor> )); //write flow-values to residuals
     752  BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<ReverseEdgeMap, edge_descriptor> )); //read out reverse edges
     753  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<PredecessorMap, vertex_descriptor> )); //store predecessor there
     754  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, vertex_descriptor> )); //write corresponding tree
     755  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DistanceMap, vertex_descriptor> )); //write distance to source/sink
     756  BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap, vertex_descriptor> )); //get index 0...|V|-1
    756757  BOOST_ASSERT(num_vertices(g) >= 2 && src != sink);
    757758
    758759  detail::bk_max_flow<

  • boost/graph/tiernan_all_cycles.hpp

     
    1313#include <boost/graph/graph_concepts.hpp>
    1414#include <boost/graph/graph_traits.hpp>
    1515#include <boost/graph/properties.hpp>
     16#include <boost/concept/assert.hpp>
    1617
    1718#include <boost/concept/detail/concept_def.hpp>
    1819namespace boost {
    … …  
    156157                    const Path& p,
    157158                    const ClosedMatrix& m)
    158159    {
    159         function_requires< IncidenceGraphConcept<Graph> >();
    160         function_requires< VertexIndexGraphConcept<Graph> >();
     160        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     161        BOOST_CONCEPT_ASSERT(( VertexIndexGraphConcept<Graph> ));
    161162        typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    162163
    163164        // get the vertices in question
    … …  
    181182    inline bool
    182183    can_wrap_path(const Graph& g, const Path& p)
    183184    {
    184         function_requires< IncidenceGraphConcept<Graph> >();
     185        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
    185186        typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    186187        typedef typename graph_traits<Graph>::out_edge_iterator OutIterator;
    187188
    … …  
    209210                Path& p,
    210211                ClosedMatrix& closed)
    211212    {
    212         function_requires< IncidenceGraphConcept<Graph> >();
     213        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
    213214        typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    214215        typedef typename graph_traits<Graph>::edge_descriptor Edge;
    215216        typedef typename graph_traits<Graph>::out_edge_iterator OutIterator;
    … …  
    238239    inline bool
    239240    exhaust_paths(const Graph& g, Path& p, ClosedMatrix& closed)
    240241    {
    241         function_requires< GraphConcept<Graph> >();
     242        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
    242243        typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    243244
    244245        // if there's more than one vertex in the path, this closes
    … …  
    272273                            std::size_t minlen,
    273274                            std::size_t maxlen)
    274275    {
    275         function_requires< VertexListGraphConcept<Graph> >();
     276        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    276277        typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    277278        typedef std::vector<Vertex> Path;
    278         function_requires< CycleVisitorConcept<Visitor,Path,Graph> >();
     279        BOOST_CONCEPT_ASSERT(( CycleVisitorConcept<Visitor,Path,Graph> ));
    279280        typedef std::vector<Vertex> VertexList;
    280281        typedef std::vector<VertexList> ClosedMatrix;
    281282
    … …  
    320321                    std::size_t minlen,
    321322                    std::size_t maxlen)
    322323{
    323     function_requires< VertexListGraphConcept<Graph> >();
     324    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    324325    typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
    325326
    326327    VertexIterator i, end;

  • boost/graph/detail/geodesic.hpp

     
    1111#include <boost/config.hpp>
    1212#include <boost/graph/graph_concepts.hpp>
    1313#include <boost/graph/numeric_values.hpp>
     14#include <boost/concept/assert.hpp>
    1415
    1516// TODO: Should this really be in detail?
    1617
    … …  
    5152                        Combinator combine,
    5253                        Distance init)
    5354    {
    54         function_requires< VertexListGraphConcept<Graph> >();
     55        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    5556        typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    5657        typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
    57         function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
    58         function_requires< NumericValueConcept<Distance> >();
     58        BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     59        BOOST_CONCEPT_ASSERT(( NumericValueConcept<Distance> ));
    5960        typedef numeric_values<Distance> DistanceNumbers;
    60         function_requires< AdaptableBinaryFunction<Combinator,Distance,Distance,Distance> >();
     61        BOOST_CONCEPT_ASSERT(( AdaptableBinaryFunction<Combinator,Distance,Distance,Distance> ));
    6162
    6263        // If there's ever an infinite distance, then we simply return
    6364        // infinity. Note that this /will/ include the a non-zero

  • boost/graph/core_numbers.hpp

     
    1515#include <boost/pending/indirect_cmp.hpp>
    1616#include <boost/graph/breadth_first_search.hpp>
    1717#include <boost/iterator/reverse_iterator.hpp>
     18#include <boost/concept/assert.hpp>
    1819
    1920/*
    2021 * core_numbers
    … …  
    4647    struct CoreNumbersVisitorConcept {
    4748        void constraints()
    4849        {
    49             function_requires< CopyConstructibleConcept<Visitor> >();
     50            BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
    5051            vis.examine_vertex(u,g);
    5152            vis.finish_vertex(u,g);
    5253            vis.examine_edge(e,g);

  • boost/graph/degree_centrality.hpp

     
    88#define BOOST_GRAPH_DEGREE_CENTRALITY_HPP
    99
    1010#include <boost/graph/graph_concepts.hpp>
     11#include <boost/concept/assert.hpp>
    1112
    1213namespace boost {
    1314
    … …  
    2829
    2930    inline degree_type operator ()(vertex_type v, const Graph& g)
    3031    {
    31         function_requires< IncidenceGraphConcept<Graph> >();
     32        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
    3233        return out_degree(v, g);
    3334    }
    3435};
    … …  
    4950
    5051    inline degree_type operator ()(vertex_type v, const Graph& g)
    5152    {
    52         function_requires< BidirectionalGraphConcept<Graph> >();
     53        BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
    5354        return in_degree(v, g);
    5455    }
    5556};
    … …  
    6465inline typename Measure::degree_type
    6566degree_centrality(const Graph& g, Vertex v, Measure measure)
    6667{
    67     function_requires< DegreeMeasureConcept<Measure, Graph> >();
     68    BOOST_CONCEPT_ASSERT(( DegreeMeasureConcept<Measure, Graph> ));
    6869    return measure(v, g);
    6970}
    7071
    … …  
    9495inline void
    9596all_degree_centralities(const Graph& g, CentralityMap cent, Measure measure)
    9697{
    97     function_requires< VertexListGraphConcept<Graph> >();
     98    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    9899    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    99100    typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
    100     function_requires< WritablePropertyMapConcept<CentralityMap,Vertex> >();
     101    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<CentralityMap,Vertex> ));
    101102    typedef typename property_traits<CentralityMap>::value_type Centrality;
    102103
    103104    VertexIterator i, end;

  • boost/graph/kruskal_min_spanning_tree.hpp

     
    2828#include <boost/graph/named_function_params.hpp>
    2929#include <boost/pending/disjoint_sets.hpp>
    3030#include <boost/pending/indirect_cmp.hpp>
     31#include <boost/concept/assert.hpp>
    3132
    3233
    3334namespace boost {
    … …  
    5152      if (num_vertices(G) == 0) return; // Nothing to do in this case
    5253      typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    5354      typedef typename graph_traits<Graph>::edge_descriptor Edge;
    54       function_requires<VertexListGraphConcept<Graph> >();
    55       function_requires<EdgeListGraphConcept<Graph> >();
    56       function_requires<OutputIteratorConcept<OutputIterator, Edge> >();
    57       function_requires<ReadWritePropertyMapConcept<Rank, Vertex> >();
    58       function_requires<ReadWritePropertyMapConcept<Parent, Vertex> >();
    59       function_requires<ReadablePropertyMapConcept<Weight, Edge> >();
     55      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     56      BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     57      BOOST_CONCEPT_ASSERT(( OutputIteratorConcept<OutputIterator, Edge> ));
     58      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<Rank, Vertex> ));
     59      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<Parent, Vertex> ));
     60      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<Weight, Edge> ));
    6061      typedef typename property_traits<Weight>::value_type W_value;
    6162      typedef typename property_traits<Rank>::value_type R_value;
    6263      typedef typename property_traits<Parent>::value_type P_value;
    63       function_requires<ComparableConcept<W_value> >();
    64       function_requires<ConvertibleConcept<P_value, Vertex> >();
    65       function_requires<IntegerConcept<R_value> >();
     64      BOOST_CONCEPT_ASSERT(( ComparableConcept<W_value> ));
     65      BOOST_CONCEPT_ASSERT(( ConvertibleConcept<P_value, Vertex> ));
     66      BOOST_CONCEPT_ASSERT(( IntegerConcept<R_value> ));
    6667
    6768      disjoint_sets<Rank, Parent>  dset(rank, parent);
    6869

  • boost/graph/dijkstra_shortest_paths.hpp

     
    3030#include <boost/property_map/property_map.hpp>
    3131#include <boost/property_map/vector_property_map.hpp>
    3232#include <boost/type_traits.hpp>
     33#include <boost/concept/assert.hpp>
    3334
    3435#ifdef BOOST_GRAPH_DIJKSTRA_TESTING
    3536#  include <boost/pending/mutable_queue.hpp>
    … …  
    6869  template <class Visitor, class Graph>
    6970  struct DijkstraVisitorConcept {
    7071    void constraints() {
    71       function_requires< CopyConstructibleConcept<Visitor> >();
     72      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
    7273      vis.initialize_vertex(u, g);
    7374      vis.discover_vertex(u, g);
    7475      vis.examine_vertex(u, g);

  • boost/graph/floyd_warshall_shortest.hpp

     
    3434#include <boost/graph/named_function_params.hpp>
    3535#include <boost/graph/graph_concepts.hpp>
    3636#include <boost/graph/relax.hpp>
     37#include <boost/concept/assert.hpp>
    3738
    3839namespace boost
    3940{
    … …  
    8485    const BinaryFunction& combine, const Infinity& inf,
    8586    const Zero& zero)
    8687  {
    87     function_requires<VertexListGraphConcept<VertexListGraph> >();
     88    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<VertexListGraph> ));
    8889 
    8990    return detail::floyd_warshall_dispatch(g, d, compare, combine,
    9091    inf, zero);
    … …  
    101102    const BinaryPredicate& compare, const BinaryFunction& combine,
    102103    const Infinity& inf, const Zero& zero)
    103104  {
    104     function_requires<VertexListGraphConcept<VertexAndEdgeListGraph> >();
    105     function_requires<EdgeListGraphConcept<VertexAndEdgeListGraph> >();
    106     function_requires<IncidenceGraphConcept<VertexAndEdgeListGraph> >();
     105    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<VertexAndEdgeListGraph> ));
     106    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<VertexAndEdgeListGraph> ));
     107    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<VertexAndEdgeListGraph> ));
    107108 
    108109    typename graph_traits<VertexAndEdgeListGraph>::vertex_iterator
    109110      firstv, lastv, firstv2, lastv2;

  • boost/graph/johnson_all_pairs_shortest.hpp

     
    2929#include <boost/graph/dijkstra_shortest_paths.hpp>
    3030#include <boost/graph/adjacency_list.hpp>
    3131#include <boost/type_traits/same_traits.hpp>
     32#include <boost/concept/assert.hpp>
    3233
    3334namespace boost {
    3435
    … …  
    4445  {
    4546    typedef graph_traits<VertexAndEdgeListGraph> Traits1;
    4647    typedef typename property_traits<Weight>::value_type DT;
    47     function_requires< BasicMatrixConcept<DistanceMatrix,
    48       typename Traits1::vertices_size_type, DT> >();
     48    BOOST_CONCEPT_ASSERT(( BasicMatrixConcept<DistanceMatrix,
     49      typename Traits1::vertices_size_type, DT> ));
    4950
    5051    typedef typename Traits1::directed_category DirCat;
    5152    bool is_undirected = is_same<DirCat, undirected_tag>::value;

  • boost/graph/connected_components.hpp

     
    1717#include <boost/graph/graph_concepts.hpp>
    1818#include <boost/graph/overloading.hpp>
    1919#include <boost/static_assert.hpp>
     20#include <boost/concept/assert.hpp>
    2021
    2122namespace boost {
    2223
    … …  
    6465    if (num_vertices(g) == 0) return 0;
    6566
    6667    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    67     function_requires< WritablePropertyMapConcept<ComponentMap, Vertex> >();
     68    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, Vertex> ));
    6869    typedef typename boost::graph_traits<Graph>::directed_category directed;
    6970    BOOST_STATIC_ASSERT((boost::is_same<directed, undirected_tag>::value));
    7071
    … …  
    8485    if (num_vertices(g) == 0) return 0;
    8586
    8687    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    87     function_requires< WritablePropertyMapConcept<ComponentMap, Vertex> >();
     88    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, Vertex> ));
    8889    typedef typename boost::graph_traits<Graph>::directed_category directed;
    8990    // BOOST_STATIC_ASSERT((boost::is_same<directed, undirected_tag>::value));
    9091

  • boost/graph/isomorphism.hpp

     
    1515#include <boost/utility.hpp>
    1616#include <boost/detail/algorithm.hpp>
    1717#include <boost/pending/indirect_cmp.hpp> // for make_indirect_pmap
     18#include <boost/concept/assert.hpp>
    1819
    1920#ifndef BOOST_GRAPH_ITERATION_MACROS_HPP
    2021#define BOOST_ISO_INCLUDED_ITER_MACROS // local macro, see bottom of file
    … …  
    322323
    323324  {
    324325    // Graph requirements
    325     function_requires< VertexListGraphConcept<Graph1> >();
    326     function_requires< EdgeListGraphConcept<Graph1> >();
    327     function_requires< VertexListGraphConcept<Graph2> >();
    328     function_requires< BidirectionalGraphConcept<Graph2> >();
     326    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
     327    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
     328    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
     329    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
    329330   
    330331    typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_t;
    331332    typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
    332333    typedef typename graph_traits<Graph1>::vertices_size_type size_type;
    333334   
    334335    // Vertex invariant requirement
    335     function_requires< AdaptableUnaryFunctionConcept<Invariant1,
    336       size_type, vertex1_t> >();
    337     function_requires< AdaptableUnaryFunctionConcept<Invariant2,
    338       size_type, vertex2_t> >();
     336    BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant1,
     337      size_type, vertex1_t> ));
     338    BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant2,
     339      size_type, vertex2_t> ));
    339340   
    340341    // Property map requirements
    341     function_requires< ReadWritePropertyMapConcept<IsoMapping, vertex1_t> >();
     342    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IsoMapping, vertex1_t> ));
    342343    typedef typename property_traits<IsoMapping>::value_type IsoMappingValue;
    343344    BOOST_STATIC_ASSERT((is_same<IsoMappingValue, vertex2_t>::value));
    344345   
    345     function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
     346    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
    346347    typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
    347348    BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
    348349   
    349     function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
     350    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
    350351    typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
    351352    BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
    352353   

  • boost/graph/dominator_tree.hpp

     
    1313#include <deque>
    1414#include <set>
    1515#include <boost/graph/depth_first_search.hpp>
     16#include <boost/concept/assert.hpp>
    1617
    1718// Dominator tree computation
    1819
    … …  
    244245    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    245246    typedef typename graph_traits<Graph>::vertices_size_type VerticesSizeType;
    246247
    247     function_requires< BidirectionalGraphConcept<Graph> >();
     248    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
    248249
    249250    const VerticesSizeType numOfVertices = num_vertices(g);
    250251    if (numOfVertices == 0) return;
    … …  
    299300    // Typedefs and concept check
    300301    typedef typename graph_traits<Graph>::vertices_size_type VerticesSizeType;
    301302
    302     function_requires< BidirectionalGraphConcept<Graph> >();
     303    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
    303304
    304305    // 1. Depth first visit
    305306    const VerticesSizeType numOfVertices = num_vertices(g);
    … …  
    388389      iterator_property_map<typename std::vector< std::set<Vertex> >::iterator,
    389390                            IndexMap> vertexSetMap;
    390391
    391     function_requires<BidirectionalGraphConcept<Graph> >();
     392    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
    392393
    393394    // 1. Finding dominator
    394395    // 1.1. Initialize

  • boost/graph/biconnected_components.hpp

     
    2020#include <boost/property_map/property_map.hpp>
    2121#include <boost/graph/depth_first_search.hpp>
    2222#include <boost/graph/graph_utility.hpp>
     23#include <boost/concept/assert.hpp>
    2324
    2425namespace boost
    2526{
    … …  
    157158  {
    158159    typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
    159160    typedef typename graph_traits<Graph>::edge_descriptor edge_t;
    160     function_requires<VertexListGraphConcept<Graph> >();
    161     function_requires<IncidenceGraphConcept<Graph> >();
    162     function_requires<WritablePropertyMapConcept<ComponentMap, edge_t> >();
    163     function_requires<ReadWritePropertyMapConcept<DiscoverTimeMap,
    164                                                   vertex_t> >();
    165     function_requires<ReadWritePropertyMapConcept<LowPointMap, vertex_t > >();
    166     function_requires<ReadWritePropertyMapConcept<PredecessorMap,
    167                                                   vertex_t> >();
     161    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     162    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     163    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, edge_t> ));
     164    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DiscoverTimeMap,
     165                                                  vertex_t> ));
     166    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<LowPointMap, vertex_t > ));
     167    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<PredecessorMap,
     168                                                  vertex_t> ));
    168169
    169170    std::size_t num_components = 0;
    170171    std::size_t dfs_time = 0;

  • boost/graph/transitive_closure.hpp

     
    1919#include <boost/graph/topological_sort.hpp>
    2020#include <boost/graph/graph_concepts.hpp>
    2121#include <boost/graph/named_function_params.hpp>
     22#include <boost/concept/assert.hpp>
    2223
    2324namespace boost
    2425{
    … …  
    7677    typedef typename graph_traits <
    7778      Graph >::adjacency_iterator adjacency_iterator;
    7879
    79     function_requires < VertexListGraphConcept < Graph > >();
    80     function_requires < AdjacencyGraphConcept < Graph > >();
    81     function_requires < VertexMutableGraphConcept < GraphTC > >();
    82     function_requires < EdgeMutableGraphConcept < GraphTC > >();
    83     function_requires < ReadablePropertyMapConcept < VertexIndexMap,
    84       vertex > >();
     80    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept < Graph > ));
     81    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept < Graph > ));
     82    BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept < GraphTC > ));
     83    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept < GraphTC > ));
     84    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept < VertexIndexMap,
     85      vertex > ));
    8586
    8687    typedef size_type cg_vertex;
    8788    std::vector < cg_vertex > component_number_vec(num_vertices(g));
    … …  
    302303    typedef typename graph_traits < G >::vertex_descriptor vertex;
    303304    typedef typename graph_traits < G >::vertex_iterator vertex_iterator;
    304305
    305     function_requires < AdjacencyMatrixConcept < G > >();
    306     function_requires < EdgeMutableGraphConcept < G > >();
     306    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept < G > ));
     307    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept < G > ));
    307308
    308309    // Matrix form:
    309310    // for k
    … …  
    328329    typedef typename graph_traits < G >::vertex_descriptor vertex;
    329330    typedef typename graph_traits < G >::vertex_iterator vertex_iterator;
    330331
    331     function_requires < AdjacencyMatrixConcept < G > >();
    332     function_requires < EdgeMutableGraphConcept < G > >();
     332    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept < G > ));
     333    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept < G > ));
    333334
    334335    // Make sure second loop will work
    335336    if (num_vertices(g) == 0)

  • boost/graph/eccentricity.hpp

     
    1010#include <boost/utility.hpp>
    1111#include <boost/config.hpp>
    1212#include <boost/graph/detail/geodesic.hpp>
     13#include <boost/concept/assert.hpp>
    1314
    1415namespace boost
    1516{
    … …  
    1920inline typename property_traits<DistanceMap>::value_type
    2021eccentricity(const Graph& g, DistanceMap dist, Combinator combine)
    2122{
    22     function_requires< GraphConcept<Graph> >();
     23    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
    2324    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    24     function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
     25    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
    2526    typedef typename property_traits<DistanceMap>::value_type Distance;
    2627
    2728    return detail::combine_distances(g, dist, combine, Distance(0));
    … …  
    3132inline typename property_traits<DistanceMap>::value_type
    3233eccentricity(const Graph& g, DistanceMap dist)
    3334{
    34     function_requires< GraphConcept<Graph> >();
     35    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
    3536    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    36     function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
     37    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
    3738    typedef typename property_traits<DistanceMap>::value_type Distance;
    3839
    3940    return eccentricity(g, dist, detail::maximize<Distance>());
    … …  
    4445                    typename property_traits<EccentricityMap>::value_type>
    4546all_eccentricities(const Graph& g, const DistanceMatrix& dist, EccentricityMap ecc)
    4647{
    47     function_requires< VertexListGraphConcept<Graph> >();
     48    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    4849    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    4950    typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
    50     function_requires< ReadablePropertyMapConcept<DistanceMatrix,Vertex> >();
     51    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrix,Vertex> ));
    5152    typedef typename property_traits<DistanceMatrix>::value_type DistanceMap;
    52     function_requires< WritablePropertyMapConcept<EccentricityMap,Vertex> >();
     53    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<EccentricityMap,Vertex> ));
    5354    typedef typename property_traits<EccentricityMap>::value_type Eccentricity;
    5455    BOOST_USING_STD_MIN();
    5556    BOOST_USING_STD_MAX();
    … …  
    7677                    typename property_traits<EccentricityMap>::value_type>
    7778radius_and_diameter(const Graph& g, EccentricityMap ecc)
    7879{
    79     function_requires< VertexListGraphConcept<Graph> >();
     80    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    8081    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    8182    typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
    82     function_requires< ReadablePropertyMapConcept<EccentricityMap, Vertex> >();
     83    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<EccentricityMap, Vertex> ));
    8384    typedef typename property_traits<EccentricityMap>::value_type Eccentricity;
    8485    BOOST_USING_STD_MIN();
    8586    BOOST_USING_STD_MAX();

  • boost/graph/closeness_centrality.hpp

     
    99
    1010#include <boost/graph/detail/geodesic.hpp>
    1111#include <boost/graph/exterior_property.hpp>
     12#include <boost/concept/assert.hpp>
    1213
    1314namespace boost
    1415{
    … …  
    2526
    2627    result_type operator ()(distance_type d, const Graph&)
    2728    {
    28         function_requires< NumericValueConcept<DistanceType> >();
    29         function_requires< NumericValueConcept<ResultType> >();
    30         function_requires< AdaptableUnaryFunctionConcept<Reciprocal,ResultType,ResultType> >();
     29        BOOST_CONCEPT_ASSERT(( NumericValueConcept<DistanceType> ));
     30        BOOST_CONCEPT_ASSERT(( NumericValueConcept<ResultType> ));
     31        BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Reciprocal,ResultType,ResultType> ));
    3132        return (d == base_type::infinite_distance())
    3233            ? base_type::zero_result()
    3334            : rec(result_type(d));
    … …  
    7576                     Measure measure,
    7677                     Combinator combine)
    7778{
    78     function_requires< VertexListGraphConcept<Graph> >();
     79    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    7980    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    80     function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
     81    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
    8182    typedef typename property_traits<DistanceMap>::value_type Distance;
    82     function_requires< NumericValueConcept<Distance> >();
    83     function_requires< DistanceMeasureConcept<Measure,Graph> >();
     83    BOOST_CONCEPT_ASSERT(( NumericValueConcept<Distance> ));
     84    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
    8485
    8586    Distance n = detail::combine_distances(g, dist, combine, Distance(0));
    8687    return measure(n, g);
    … …  
    9091inline typename Measure::result_type
    9192closeness_centrality(const Graph& g, DistanceMap dist, Measure measure)
    9293{
    93     function_requires< GraphConcept<Graph> >();
     94    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
    9495    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    95     function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
     96    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
    9697    typedef typename property_traits<DistanceMap>::value_type Distance;
    9798
    9899    return closeness_centrality(g, dist, measure, std::plus<Distance>());
    … …  
    116117                           CentralityMap cent,
    117118                           Measure measure)
    118119{
    119     function_requires< VertexListGraphConcept<Graph> >();
     120    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    120121    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    121     function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
     122    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
    122123    typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
    123     function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
    124     function_requires< WritablePropertyMapConcept<CentralityMap,Vertex> >();
     124    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     125    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<CentralityMap,Vertex> ));
    125126    typedef typename property_traits<DistanceMap>::value_type Distance;
    126127    typedef typename property_traits<CentralityMap>::value_type Centrality;
    127128
    … …  
    141142                            DistanceMatrixMap dist,
    142143                            CentralityMap cent)
    143144{
    144     function_requires< GraphConcept<Graph> >();
     145    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
    145146    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    146     function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
     147    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
    147148    typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
    148     function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
     149    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
    149150    typedef typename property_traits<DistanceMap>::value_type Distance;
    150151    typedef typename property_traits<CentralityMap>::value_type Result;
    151152

  • boost/graph/strong_components.hpp

     
    1818#include <boost/type_traits/conversion_traits.hpp>
    1919#include <boost/static_assert.hpp>
    2020#include <boost/graph/overloading.hpp>
     21#include <boost/concept/assert.hpp>
    2122
    2223namespace boost {
    2324
    … …  
    9394       const bgl_named_params<P, T, R>& params)
    9495    {
    9596      typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    96       function_requires< ReadWritePropertyMapConcept<ComponentMap, Vertex> >();
    97       function_requires< ReadWritePropertyMapConcept<RootMap, Vertex> >();
     97      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ComponentMap, Vertex> ));
     98      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<RootMap, Vertex> ));
    9899      typedef typename property_traits<RootMap>::value_type RootV;
    99       function_requires< ConvertibleConcept<RootV, Vertex> >();
    100       function_requires< ReadWritePropertyMapConcept<DiscoverTime, Vertex> >();
     100      BOOST_CONCEPT_ASSERT(( ConvertibleConcept<RootV, Vertex> ));
     101      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DiscoverTime, Vertex> ));
    101102
    102103      typename property_traits<ComponentMap>::value_type total = 0;
    103104
    … …  
    282283  kosaraju_strong_components(Graph& G, ComponentsMap c,
    283284                             FinishTime finish_time, ColorMap color)
    284285  {
    285     function_requires< MutableGraphConcept<Graph> >();
     286    BOOST_CONCEPT_ASSERT(( MutableGraphConcept<Graph> ));
    286287    // ...
    287288   
    288289    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;

  • boost/graph/graph_concepts.hpp

     
    2121#include <boost/graph/buffer_concepts.hpp>
    2222#include <boost/concept_check.hpp>
    2323#include <boost/detail/workaround.hpp>
     24#include <boost/concept/assert.hpp>
    2425
    2526#include <boost/concept/detail/concept_def.hpp>
    2627namespace boost
    … …  
    529530    {
    530531        BOOST_CONCEPT_USAGE(NumericValue)
    531532        {
    532             function_requires< DefaultConstructible<Numeric> >();
    533             function_requires< CopyConstructible<Numeric> >();
     533            BOOST_CONCEPT_ASSERT(( DefaultConstructible<Numeric> ));
     534            BOOST_CONCEPT_ASSERT(( CopyConstructible<Numeric> ));
    534535            numeric_values<Numeric>::zero();
    535536            numeric_values<Numeric>::infinity();
    536537        }

  • boost/graph/depth_first_search.hpp

     
    2121#include <boost/graph/named_function_params.hpp>
    2222#include <boost/ref.hpp>
    2323#include <boost/implicit_cast.hpp>
     24#include <boost/concept/assert.hpp>
    2425
    2526#include <vector>
    2627#include <utility>
    … …  
    3132  class DFSVisitorConcept {
    3233  public:
    3334    void constraints() {
    34       function_requires< CopyConstructibleConcept<Visitor> >();
     35      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
    3536      vis.initialize_vertex(u, g);
    3637      vis.start_vertex(u, g);
    3738      vis.discover_vertex(u, g);
    … …  
    8081       DFSVisitor& vis,
    8182       ColorMap color, TerminatorFunc func = TerminatorFunc())
    8283    {
    83       function_requires<IncidenceGraphConcept<IncidenceGraph> >();
    84       function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
     84      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
     85      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
    8586      typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
    86       function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
     87      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
    8788      typedef typename property_traits<ColorMap>::value_type ColorValue;
    88       function_requires< ColorValueConcept<ColorValue> >();
     89      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
    8990      typedef color_traits<ColorValue> Color;
    9091      typedef typename graph_traits<IncidenceGraph>::out_edge_iterator Iter;
    9192      typedef std::pair<Vertex, std::pair<Iter, Iter> > VertexInfo;
    … …  
    151152       DFSVisitor& vis,  // pass-by-reference here, important!
    152153       ColorMap color, TerminatorFunc func)
    153154    {
    154       function_requires<IncidenceGraphConcept<IncidenceGraph> >();
    155       function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
     155      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
     156      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
    156157      typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
    157       function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
     158      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
    158159      typedef typename property_traits<ColorMap>::value_type ColorValue;
    159       function_requires< ColorValueConcept<ColorValue> >();
     160      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
    160161      typedef color_traits<ColorValue> Color;
    161162      typename graph_traits<IncidenceGraph>::out_edge_iterator ei, ei_end;
    162163
    … …  
    187188                     typename graph_traits<VertexListGraph>::vertex_descriptor start_vertex)
    188189  {
    189190    typedef typename graph_traits<VertexListGraph>::vertex_descriptor Vertex;
    190     function_requires<DFSVisitorConcept<DFSVisitor, VertexListGraph> >();
     191    BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, VertexListGraph> ));
    191192    typedef typename property_traits<ColorMap>::value_type ColorValue;
    192193    typedef color_traits<ColorValue> Color;
    193194

  • boost/graph/distributed/concepts.hpp

     
    2121#include <boost/version.hpp>
    2222#include <boost/graph/graph_traits.hpp>
    2323#include <boost/graph/graph_concepts.hpp>
     24#include <boost/concept/assert.hpp>
    2425
    2526#if BOOST_VERSION >= 103500
    2627#  include <boost/concept/detail/concept_def.hpp>
    … …  
    4647  typedef typename graph_traits<G>::traversal_category
    4748    traversal_category;
    4849  void constraints() {
    49     function_requires< GraphConcept<G> >();
    50     function_requires< MultiPassInputIteratorConcept<vertex_iterator> >();
    51     function_requires< ConvertibleConcept<traversal_category,
    52       distributed_vertex_list_graph_tag> >();
     50    BOOST_CONCEPT_ASSERT(( GraphConcept<G> ));
     51    BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept<vertex_iterator> ));
     52    BOOST_CONCEPT_ASSERT(( ConvertibleConcept<traversal_category,
     53      distributed_vertex_list_graph_tag> ));
    5354
    5455#ifdef BOOST_VECTOR_AS_GRAPH_GRAPH_ADL_HACK
    5556    // dwa 2003/7/11 -- This clearly shouldn't be necessary, but if
    … …  
    9293  typedef typename graph_traits<G>::traversal_category
    9394    traversal_category;
    9495  void constraints() {
    95     function_requires< GraphConcept<G> >();
    96     function_requires< MultiPassInputIteratorConcept<edge_iterator> >();
    97     function_requires< DefaultConstructibleConcept<edge_descriptor> >();
    98     function_requires< EqualityComparableConcept<edge_descriptor> >();
    99     function_requires< AssignableConcept<edge_descriptor> >();
    100     function_requires< ConvertibleConcept<traversal_category,
    101       distributed_edge_list_graph_tag> >();
     96    BOOST_CONCEPT_ASSERT(( GraphConcept<G> ));
     97    BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept<edge_iterator> ));
     98    BOOST_CONCEPT_ASSERT(( DefaultConstructibleConcept<edge_descriptor> ));
     99    BOOST_CONCEPT_ASSERT(( EqualityComparableConcept<edge_descriptor> ));
     100    BOOST_CONCEPT_ASSERT(( AssignableConcept<edge_descriptor> ));
     101    BOOST_CONCEPT_ASSERT(( ConvertibleConcept<traversal_category,
     102      distributed_edge_list_graph_tag> ));
    102103
    103104    p = edges(g);
    104105    e = *p.first;

  • boost/graph/distributed/hohberg_biconnected_components.hpp

     
    4444#include <vector>
    4545#include <boost/graph/parallel/algorithm.hpp>
    4646#include <boost/graph/distributed/connected_components.hpp>
     47#include <boost/concept/assert.hpp>
    4748
    4849namespace boost { namespace graph { namespace distributed {
    4950
    … …  
    908909                    undirected_tag>::value));
    909910
    910911  // The graph must model Incidence Graph
    911   function_requires< IncidenceGraphConcept<Graph> >();
     912  BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
    912913
    913914  typedef typename graph_traits<Graph>::edges_size_type edges_size_type;
    914915  typedef typename graph_traits<Graph>::degree_size_type degree_size_type;

  • boost/graph/geodesic_distance.hpp

     
    99
    1010#include <boost/graph/detail/geodesic.hpp>
    1111#include <boost/graph/exterior_property.hpp>
     12#include <boost/concept/assert.hpp>
    1213
    1314namespace boost
    1415{
    … …  
    2526
    2627    result_type operator ()(distance_type d, const Graph& g)
    2728    {
    28         function_requires< VertexListGraphConcept<Graph> >();
    29         function_requires< NumericValueConcept<DistanceType> >();
    30         function_requires< NumericValueConcept<ResultType> >();
    31         function_requires< AdaptableBinaryFunctionConcept<Divides,ResultType,ResultType,ResultType> >();
     29        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     30        BOOST_CONCEPT_ASSERT(( NumericValueConcept<DistanceType> ));
     31        BOOST_CONCEPT_ASSERT(( NumericValueConcept<ResultType> ));
     32        BOOST_CONCEPT_ASSERT(( AdaptableBinaryFunctionConcept<Divides,ResultType,ResultType,ResultType> ));
    3233
    3334        return (d == base_type::infinite_distance())
    3435            ? base_type::infinite_result()
    … …  
    6970
    7071    inline result_type operator ()(distance_type d, const Graph& g)
    7172    {
    72         function_requires< VertexListGraphConcept<Graph> >();
    73         function_requires< NumericValueConcept<DistanceType> >();
     73        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     74        BOOST_CONCEPT_ASSERT(( NumericValueConcept<DistanceType> ));
    7475
    7576        if(d == base_type::infinite_distance()) {
    7677            return base_type::infinite_result();
    … …  
    99100                Measure measure,
    100101                Combinator combine)
    101102{
    102     function_requires< DistanceMeasureConcept<Measure,Graph> >();
     103    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
    103104    typedef typename Measure::distance_type Distance;
    104105
    105106    Distance n = detail::combine_distances(g, dist, combine, Distance(0));
    … …  
    112113inline typename Measure::result_type
    113114mean_geodesic(const Graph& g, DistanceMap dist, Measure measure)
    114115{
    115     function_requires< DistanceMeasureConcept<Measure,Graph> >();
     116    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
    116117    typedef typename Measure::distance_type Distance;
    117118
    118119    return mean_geodesic(g, dist, measure, std::plus<Distance>());
    … …  
    139140                    GeodesicMap geo,
    140141                    Measure measure)
    141142{
    142     function_requires< VertexListGraphConcept<Graph> >();
     143    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    143144    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    144145    typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
    145     function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
     146    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
    146147    typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
    147     function_requires< DistanceMeasureConcept<Measure,Graph> >();
     148    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
    148149    typedef typename Measure::result_type Result;
    149     function_requires< WritablePropertyMapConcept<GeodesicMap,Vertex> >();
    150     function_requires< NumericValueConcept<Result> >();
     150    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<GeodesicMap,Vertex> ));
     151    BOOST_CONCEPT_ASSERT(( NumericValueConcept<Result> ));
    151152
    152153    // NOTE: We could compute the mean geodesic here by performing additional
    153154    // computations (i.e., adding and dividing). However, I don't really feel
    … …  
    178179inline typename property_traits<GeodesicMap>::value_type
    179180all_mean_geodesics(const Graph& g, DistanceMatrixMap dist, GeodesicMap geo)
    180181{
    181     function_requires< GraphConcept<Graph> >();
     182    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
    182183    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    183     function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
     184    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
    184185    typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
    185     function_requires< WritablePropertyMapConcept<GeodesicMap,Vertex> >();
     186    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<GeodesicMap,Vertex> ));
    186187    typedef typename property_traits<GeodesicMap>::value_type Result;
    187188
    188189    return all_mean_geodesics(g, dist, geo, measure_mean_geodesic<Result>(g, DistanceMap()));
    … …  
    193194inline typename Measure::result_type
    194195small_world_distance(const Graph& g, GeodesicMap geo, Measure measure)
    195196{
    196     function_requires< DistanceMeasureConcept<Measure,Graph> >();
     197    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
    197198    typedef typename Measure::result_type Result;
    198199
    199200    Result sum = detail::combine_distances(g, geo, std::plus<Result>(), Result(0));

  • boost/graph/astar_search.hpp

     
    2525#include <boost/graph/detail/d_ary_heap.hpp>
    2626#include <boost/property_map/property_map.hpp>
    2727#include <boost/property_map/vector_property_map.hpp>
     28#include <boost/concept/assert.hpp>
    2829
    29 
    3030namespace boost {
    3131
    3232
    … …  
    3434  struct AStarHeuristicConcept {
    3535    void constraints()
    3636    {
    37       function_requires< CopyConstructibleConcept<Heuristic> >();
     37      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Heuristic> ));
    3838      h(u);
    3939    }
    4040    Heuristic h;
    … …  
    5858  struct AStarVisitorConcept {
    5959    void constraints()
    6060    {
    61       function_requires< CopyConstructibleConcept<Visitor> >();
     61      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
    6262      vis.initialize_vertex(u, g);
    6363      vis.discover_vertex(u, g);
    6464      vis.examine_vertex(u, g);

  • boost/graph/howard_cycle_ratio.hpp

     
    2020#include <boost/property_map/property_map.hpp>
    2121#include <boost/graph/graph_traits.hpp>
    2222#include <boost/graph/graph_concepts.hpp>
     23#include <boost/concept/assert.hpp>
    2324
    2425/** @file howard_cycle_ratio.hpp
    2526 * @brief The implementation of the maximum/minimum cycle ratio/mean algorithm.
    … …  
    477478    {
    478479      typedef typename graph_traits<TG>::directed_category DirCat;
    479480      BOOST_STATIC_ASSERT((is_convertible<DirCat*, directed_tag*>::value == true));
    480       function_requires< IncidenceGraphConcept<TG> >();
    481       function_requires< VertexListGraphConcept<TG> >();
     481      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<TG> ));
     482      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<TG> ));
    482483      typedef typename graph_traits<TG>::vertex_descriptor Vertex;
    483       function_requires< ReadablePropertyMapConcept<TVIM, Vertex> >();
     484      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<TVIM, Vertex> ));
    484485      typedef typename graph_traits<TG>::edge_descriptor Edge;
    485       function_requires< ReadablePropertyMapConcept<TEW1, Edge> >();
    486       function_requires< ReadablePropertyMapConcept<TEW2, Edge> >();
     486      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<TEW1, Edge> ));
     487      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<TEW2, Edge> ));
    487488
    488489      if(pcc == 0) {
    489490          return detail::mcr_howard<FT,TG, TVIM, TEW1, TEW2>(

  • boost/graph/breadth_first_search.hpp

     
    2424#include <boost/graph/overloading.hpp>
    2525#include <boost/graph/graph_concepts.hpp>
    2626#include <boost/graph/two_bit_color_map.hpp>
     27#include <boost/concept/assert.hpp>
    2728
    2829#ifdef BOOST_GRAPH_USE_MPI
    2930#include <boost/graph/distributed/concepts.hpp>
    … …  
    3435  template <class Visitor, class Graph>
    3536  struct BFSVisitorConcept {
    3637    void constraints() {
    37       function_requires< CopyConstructibleConcept<Visitor> >();
     38      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
    3839      vis.initialize_vertex(u, g);
    3940      vis.discover_vertex(u, g);
    4041      vis.examine_vertex(u, g);
    … …  
    5960     typename graph_traits<IncidenceGraph>::vertex_descriptor s,
    6061     Buffer& Q, BFSVisitor vis, ColorMap color)
    6162  {
    62     function_requires< IncidenceGraphConcept<IncidenceGraph> >();
     63    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
    6364    typedef graph_traits<IncidenceGraph> GTraits;
    6465    typedef typename GTraits::vertex_descriptor Vertex;
    6566    typedef typename GTraits::edge_descriptor Edge;
    66     function_requires< BFSVisitorConcept<BFSVisitor, IncidenceGraph> >();
    67     function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
     67    BOOST_CONCEPT_ASSERT(( BFSVisitorConcept<BFSVisitor, IncidenceGraph> ));
     68    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
    6869    typedef typename property_traits<ColorMap>::value_type ColorValue;
    6970    typedef color_traits<ColorValue> Color;
    7071    typename GTraits::out_edge_iterator ei, ei_end;

  • boost/graph/neighbor_bfs.hpp

     
    2424#include <boost/graph/graph_concepts.hpp>
    2525#include <boost/graph/visitors.hpp>
    2626#include <boost/graph/named_function_params.hpp>
     27#include <boost/concept/assert.hpp>
    2728
    2829namespace boost {
    2930
    3031  template <class Visitor, class Graph>
    3132  struct NeighborBFSVisitorConcept {
    3233    void constraints() {
    33       function_requires< CopyConstructibleConcept<Visitor> >();
     34      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
    3435      vis.initialize_vertex(u, g);
    3536      vis.discover_vertex(u, g);
    3637      vis.examine_vertex(u, g);
    … …  
    133134       Buffer& Q, BFSVisitor vis, ColorMap color)
    134135
    135136    {
    136       function_requires< BidirectionalGraphConcept<BidirectionalGraph> >();
     137      BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<BidirectionalGraph> ));
    137138      typedef graph_traits<BidirectionalGraph> GTraits;
    138139      typedef typename GTraits::vertex_descriptor Vertex;
    139140      typedef typename GTraits::edge_descriptor Edge;
    140       function_requires<
    141         NeighborBFSVisitorConcept<BFSVisitor, BidirectionalGraph> >();
    142       function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
     141      BOOST_CONCEPT_ASSERT((
     142        NeighborBFSVisitorConcept<BFSVisitor, BidirectionalGraph> ));
     143      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
    143144      typedef typename property_traits<ColorMap>::value_type ColorValue;
    144145      typedef color_traits<ColorValue> Color;
    145146     

  • libs/graph/test/test_construction.hpp

     
    77#ifndef TEST_CONSTRUCTION_HPP
    88#define TEST_CONSTRUCTION_HPP
    99
     10#include <boost/concept/assert.hpp>
    1011#include <utility>
    1112
    1213/** @name Build Graph

  • libs/graph/test/adj_list_cc.cpp

     
    99#include <boost/graph/graph_concepts.hpp>
    1010#include <boost/graph/graph_archetypes.hpp>
    1111#include <boost/graph/adjacency_list.hpp>
     12#include <boost/concept/assert.hpp>
    1213
    1314int main(int,char*[])
    1415{
    … …  
    2122    > Graph;
    2223    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    2324    typedef graph_traits<Graph>::edge_descriptor Edge;
    24     function_requires< VertexListGraphConcept<Graph> >();
    25     function_requires< EdgeListGraphConcept<Graph> >();
    26     function_requires< IncidenceGraphConcept<Graph> >();
    27     function_requires< AdjacencyGraphConcept<Graph> >();
    28     function_requires< MutableIncidenceGraphConcept<Graph> >();
    29     function_requires< MutableEdgeListGraphConcept<Graph> >();
    30     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    31     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    32     function_requires<
    33       ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
    34     function_requires<
    35       LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    36     function_requires<
    37       LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     25    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     26    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     27    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     28    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     29    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
     30    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
     31    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     32    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     33    BOOST_CONCEPT_ASSERT((
     34      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
     35    BOOST_CONCEPT_ASSERT((
     36      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     37    BOOST_CONCEPT_ASSERT((
     38      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    3839  }
    3940  {
    4041    typedef adjacency_list<vecS, vecS, bidirectionalS,
    … …  
    4344    > Graph;
    4445    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    4546    typedef graph_traits<Graph>::edge_descriptor Edge;
    46     function_requires< VertexListGraphConcept<Graph> >();
    47     function_requires< EdgeListGraphConcept<Graph> >();
    48     function_requires< IncidenceGraphConcept<Graph> >();
    49     function_requires< AdjacencyGraphConcept<Graph> >();
    50     function_requires< BidirectionalGraphConcept<Graph> >();
    51     function_requires< MutableBidirectionalGraphConcept<Graph> >();
    52     function_requires< MutableEdgeListGraphConcept<Graph> >();
    53     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    54     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    55     function_requires<
    56       ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
    57     function_requires<
    58       LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    59     function_requires<
    60       LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     47    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     48    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     49    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     50    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     51    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
     52    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
     53    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
     54    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     55    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     56    BOOST_CONCEPT_ASSERT((
     57      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
     58    BOOST_CONCEPT_ASSERT((
     59      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     60    BOOST_CONCEPT_ASSERT((
     61      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    6162  }
    6263  {
    6364    typedef adjacency_list< listS, listS, directedS,
    … …  
    6667    > Graph;
    6768    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    6869    typedef graph_traits<Graph>::edge_descriptor Edge;
    69     function_requires< VertexListGraphConcept<Graph> >();
    70     function_requires< EdgeListGraphConcept<Graph> >();
    71     function_requires< IncidenceGraphConcept<Graph> >();
    72     function_requires< AdjacencyGraphConcept<Graph> >();
    73     function_requires< MutableIncidenceGraphConcept<Graph> >();
    74     function_requires< MutableEdgeListGraphConcept<Graph> >();
    75     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    76     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    77     function_requires<
    78       ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
    79     function_requires<
    80       LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    81     function_requires<
    82       LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     70    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     71    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     72    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     73    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     74    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
     75    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
     76    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     77    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     78    BOOST_CONCEPT_ASSERT((
     79      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
     80    BOOST_CONCEPT_ASSERT((
     81      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     82    BOOST_CONCEPT_ASSERT((
     83      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    8384  }
    8485  {
    8586    typedef adjacency_list< listS, listS, undirectedS,
    … …  
    8889    > Graph;
    8990    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    9091    typedef graph_traits<Graph>::edge_descriptor Edge;
    91     function_requires< VertexListGraphConcept<Graph> >();
    92     function_requires< EdgeListGraphConcept<Graph> >();
    93     function_requires< IncidenceGraphConcept<Graph> >();
    94     function_requires< AdjacencyGraphConcept<Graph> >();
    95     function_requires< MutableBidirectionalGraphConcept<Graph> >();
    96     function_requires< MutableEdgeListGraphConcept<Graph> >();
    97     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    98     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    99     function_requires<
    100       ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
    101     function_requires<
    102       LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    103     function_requires<
    104       LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     92    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     93    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     94    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     95    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     96    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
     97    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
     98    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     99    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     100    BOOST_CONCEPT_ASSERT((
     101      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
     102    BOOST_CONCEPT_ASSERT((
     103      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     104    BOOST_CONCEPT_ASSERT((
     105      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    105106  }
    106107  // Checking adjacency_list with EdgeList=setS
    107108  {
    … …  
    111112    > Graph;
    112113    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    113114    typedef graph_traits<Graph>::edge_descriptor Edge;
    114     function_requires< VertexListGraphConcept<Graph> >();
    115     function_requires< EdgeListGraphConcept<Graph> >();
    116     function_requires< IncidenceGraphConcept<Graph> >();
    117     function_requires< AdjacencyGraphConcept<Graph> >();
    118     function_requires< BidirectionalGraphConcept<Graph> >();
    119     function_requires< MutableBidirectionalGraphConcept<Graph> >();
    120     function_requires< MutableEdgeListGraphConcept<Graph> >();
    121     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    122     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    123     function_requires<
    124       ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
    125     function_requires<
    126       LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    127     function_requires<
    128       LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     115    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     116    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     117    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     118    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     119    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
     120    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
     121    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
     122    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     123    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     124    BOOST_CONCEPT_ASSERT((
     125      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
     126    BOOST_CONCEPT_ASSERT((
     127      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     128    BOOST_CONCEPT_ASSERT((
     129      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    129130  }
    130131  {
    131132    typedef adjacency_list< setS, listS, directedS,
    … …  
    134135    > Graph;
    135136    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    136137    typedef graph_traits<Graph>::edge_descriptor Edge;
    137     function_requires< VertexListGraphConcept<Graph> >();
    138     function_requires< EdgeListGraphConcept<Graph> >();
    139     function_requires< IncidenceGraphConcept<Graph> >();
    140     function_requires< AdjacencyGraphConcept<Graph> >();
    141     function_requires< MutableIncidenceGraphConcept<Graph> >();
    142     function_requires< MutableEdgeListGraphConcept<Graph> >();
    143     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    144     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    145     function_requires<
    146       ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
    147     function_requires<
    148       LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    149     function_requires<
    150       LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     138    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     139    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     140    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     141    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     142    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
     143    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
     144    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     145    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     146    BOOST_CONCEPT_ASSERT((
     147      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
     148    BOOST_CONCEPT_ASSERT((
     149      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     150    BOOST_CONCEPT_ASSERT((
     151      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    151152  }
    152153  {
    153154    typedef adjacency_list< setS, listS, undirectedS,
    … …  
    156157    > Graph;
    157158    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    158159    typedef graph_traits<Graph>::edge_descriptor Edge;
    159     function_requires< VertexListGraphConcept<Graph> >();
    160     function_requires< EdgeListGraphConcept<Graph> >();
    161     function_requires< IncidenceGraphConcept<Graph> >();
    162     function_requires< AdjacencyGraphConcept<Graph> >();
    163     function_requires< MutableBidirectionalGraphConcept<Graph> >();
    164     function_requires< MutableEdgeListGraphConcept<Graph> >();
    165     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    166     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    167     function_requires<
    168       ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
    169     function_requires<
    170       LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    171     function_requires<
    172       LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     160    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     161    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     162    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     163    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     164    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
     165    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
     166    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     167    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     168    BOOST_CONCEPT_ASSERT((
     169      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
     170    BOOST_CONCEPT_ASSERT((
     171      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     172    BOOST_CONCEPT_ASSERT((
     173      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    173174  }
    174175  // Check adjacency_list without any properties
    175176  {
    176177    typedef adjacency_list<vecS, vecS, directedS > Graph;
    177178    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    178179    typedef graph_traits<Graph>::edge_descriptor Edge;
    179     function_requires< VertexListGraphConcept<Graph> >();
    180     function_requires< EdgeListGraphConcept<Graph> >();
    181     function_requires< IncidenceGraphConcept<Graph> >();
    182     function_requires< AdjacencyGraphConcept<Graph> >();
    183     function_requires< MutableIncidenceGraphConcept<Graph> >();
    184     function_requires< MutableEdgeListGraphConcept<Graph> >();
    185     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    186     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    187     function_requires<
    188       ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
     180    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     181    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     182    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     183    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     184    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
     185    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
     186    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     187    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     188    BOOST_CONCEPT_ASSERT((
     189      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
    189190  }
    190191  {
    191192    typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;
    192193    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    193194    typedef graph_traits<Graph>::edge_descriptor Edge;
    194     function_requires< VertexListGraphConcept<Graph> >();
    195     function_requires< EdgeListGraphConcept<Graph> >();
    196     function_requires< IncidenceGraphConcept<Graph> >();
    197     function_requires< AdjacencyGraphConcept<Graph> >();
    198     function_requires< BidirectionalGraphConcept<Graph> >();
    199     function_requires< MutableBidirectionalGraphConcept<Graph> >();
    200     function_requires< MutableEdgeListGraphConcept<Graph> >();
    201     function_requires<
    202       ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
     195    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     196    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     197    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     198    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     199    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
     200    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
     201    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
     202    BOOST_CONCEPT_ASSERT((
     203      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
    203204  }
    204205  {
    205206    typedef adjacency_list< listS, listS, directedS> Graph;
    206207    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    207208    typedef graph_traits<Graph>::edge_descriptor Edge;
    208     function_requires< VertexListGraphConcept<Graph> >();
    209     function_requires< EdgeListGraphConcept<Graph> >();
    210     function_requires< IncidenceGraphConcept<Graph> >();
    211     function_requires< AdjacencyGraphConcept<Graph> >();
    212     function_requires< MutableIncidenceGraphConcept<Graph> >();
    213     function_requires< MutableEdgeListGraphConcept<Graph> >();
     209    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     210    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     211    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     212    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     213    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
     214    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
    214215  }
    215216  {
    216217    typedef adjacency_list< listS, listS, undirectedS> Graph;
    217218    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    218219    typedef graph_traits<Graph>::edge_descriptor Edge;
    219     function_requires< VertexListGraphConcept<Graph> >();
    220     function_requires< EdgeListGraphConcept<Graph> >();
    221     function_requires< IncidenceGraphConcept<Graph> >();
    222     function_requires< AdjacencyGraphConcept<Graph> >();
    223     function_requires< MutableBidirectionalGraphConcept<Graph> >();
    224     function_requires< MutableEdgeListGraphConcept<Graph> >();
     220    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     221    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     222    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     223    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     224    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
     225    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
    225226  }
    226227  // Checking EdgeList=setS with no properties
    227228  {
    228229    typedef adjacency_list<setS, vecS, bidirectionalS> Graph;
    229230    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    230231    typedef graph_traits<Graph>::edge_descriptor Edge;
    231     function_requires< VertexListGraphConcept<Graph> >();
    232     function_requires< EdgeListGraphConcept<Graph> >();
    233     function_requires< IncidenceGraphConcept<Graph> >();
    234     function_requires< AdjacencyGraphConcept<Graph> >();
    235     function_requires< BidirectionalGraphConcept<Graph> >();
    236     function_requires< MutableBidirectionalGraphConcept<Graph> >();
    237     function_requires< MutableEdgeListGraphConcept<Graph> >();
    238     function_requires< ReadablePropertyGraphConcept<Graph,
    239       Vertex, vertex_index_t> >();
     232    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     233    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     234    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     235    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     236    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
     237    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
     238    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
     239    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph,
     240      Vertex, vertex_index_t> ));
    240241  }
    241242  {
    242243    typedef adjacency_list< setS, listS, directedS> Graph;
    243244    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    244245    typedef graph_traits<Graph>::edge_descriptor Edge;
    245     function_requires< MutableIncidenceGraphConcept<Graph> >();
    246     function_requires< MutableEdgeListGraphConcept<Graph> >();
     246    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
     247    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
    247248  }
    248249  {
    249250    typedef adjacency_list< setS, listS, undirectedS> Graph;
    250251    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    251252    typedef graph_traits<Graph>::edge_descriptor Edge;
    252     function_requires< VertexListGraphConcept<Graph> >();
    253     function_requires< EdgeListGraphConcept<Graph> >();
    254     function_requires< IncidenceGraphConcept<Graph> >();
    255     function_requires< AdjacencyGraphConcept<Graph> >();
    256     function_requires< MutableBidirectionalGraphConcept<Graph> >();
    257     function_requires< MutableEdgeListGraphConcept<Graph> >();
     253    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     254    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     255    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     256    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     257    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
     258    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
    258259  }
    259260  return 0;
    260261}

  • libs/graph/test/graph_concepts.cpp

     
    88//=======================================================================
    99#include <boost/graph/graph_concepts.hpp>
    1010#include <boost/graph/graph_archetypes.hpp>
     11#include <boost/concept/assert.hpp>
    1112
    1213int main(int,char*[])
    1314{
    … …  
    1920
    2021  typedef incidence_graph_archetype<Vertex, directed_tag,
    2122    allow_parallel_edge_tag> Graph1;
    22   function_requires< IncidenceGraphConcept<Graph1> >();
     23  BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph1> ));
    2324
    2425  typedef adjacency_graph_archetype<Vertex, directed_tag,
    2526    allow_parallel_edge_tag> Graph2;
    26   function_requires< AdjacencyGraphConcept<Graph2> >();
     27  BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph2> ));
    2728
    2829  typedef vertex_list_graph_archetype<Vertex, directed_tag,
    2930    allow_parallel_edge_tag> Graph3;
    30   function_requires< VertexListGraphConcept<Graph3> >();
     31  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph3> ));
    3132
    32   function_requires< ColorValueConcept<color_value_archetype> >();
     33  BOOST_CONCEPT_ASSERT(( ColorValueConcept<color_value_archetype> ));
    3334
    3435  typedef incidence_graph_archetype<Vertex, directed_tag, allow_parallel_edge_tag> G;
    3536  typedef property_graph_archetype<G, vertex_color_t, color_value_archetype>
    3637    Graph4;
    37   function_requires< PropertyGraphConcept<Graph4, Vertex, vertex_color_t> >();
     38  BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph4, Vertex, vertex_color_t> ));
    3839
    3940  return 0;
    4041}

  • libs/graph/test/grid_graph_cc.cpp

     
    1010#include <boost/graph/graph_archetypes.hpp>
    1111#include <boost/graph/graph_concepts.hpp>
    1212#include <boost/graph/grid_graph.hpp>
     13#include <boost/concept/assert.hpp>
    1314
    1415#define DIMENSIONS 3
    1516using namespace boost;
    … …  
    2021  typedef graph_traits<Graph>::vertex_descriptor Vertex;
    2122  typedef graph_traits<Graph>::edge_descriptor Edge;
    2223
    23   function_requires<BidirectionalGraphConcept<Graph> >();
    24   function_requires<VertexListGraphConcept<Graph> >();
    25   function_requires<EdgeListGraphConcept<Graph> >();
    26   function_requires<IncidenceGraphConcept<Graph> >();
    27   function_requires<AdjacencyGraphConcept<Graph> >();
    28   function_requires<AdjacencyMatrixConcept<Graph> >();
    29   function_requires<ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
    30   function_requires<ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> >();
     24  BOOST_CONCEPT_ASSERT((BidirectionalGraphConcept<Graph> ));
     25  BOOST_CONCEPT_ASSERT((VertexListGraphConcept<Graph> ));
     26  BOOST_CONCEPT_ASSERT((EdgeListGraphConcept<Graph> ));
     27  BOOST_CONCEPT_ASSERT((IncidenceGraphConcept<Graph> ));
     28  BOOST_CONCEPT_ASSERT((AdjacencyGraphConcept<Graph> ));
     29  BOOST_CONCEPT_ASSERT((AdjacencyMatrixConcept<Graph> ));
     30  BOOST_CONCEPT_ASSERT((ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
     31  BOOST_CONCEPT_ASSERT((ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> ));
    3132
    3233  return (0);
    3334}

  • libs/graph/test/filtered_graph_cc.cpp

     
    1010#include <boost/graph/graph_archetypes.hpp>
    1111#include <boost/graph/adjacency_list.hpp>
    1212#include <boost/graph/filtered_graph.hpp>
     13#include <boost/concept/assert.hpp>
    1314
    1415int main(int,char*[])
    1516{
    … …  
    2223    typedef filtered_graph<Graph, is_residual_edge<ResCapMap> > ResGraph;
    2324    typedef graph_traits<ResGraph>::edge_descriptor Edge;
    2425
    25     function_requires< VertexListGraphConcept<ResGraph> >();
    26     function_requires< EdgeListGraphConcept<ResGraph> >();
    27     function_requires< IncidenceGraphConcept<ResGraph> >();
    28     function_requires< AdjacencyGraphConcept<ResGraph> >();
    29     function_requires< PropertyGraphConcept<ResGraph, Edge,
    30       edge_residual_capacity_t> >();
     26    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<ResGraph> ));
     27    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<ResGraph> ));
     28    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<ResGraph> ));
     29    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<ResGraph> ));
     30    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<ResGraph, Edge,
     31      edge_residual_capacity_t> ));
    3132  }
    3233  // Check filtered_graph with bidirectional adjacency_list
    3334  {
    … …  
    3536      no_property, property<edge_residual_capacity_t, long> > Graph;
    3637    typedef property_map<Graph, edge_residual_capacity_t>::type ResCapMap;
    3738    typedef filtered_graph<Graph, is_residual_edge<ResCapMap> > ResGraph;
    38     function_requires< BidirectionalGraphConcept<ResGraph> >();
     39    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<ResGraph> ));
    3940  }
    4041  return 0;
    4142}

  • libs/graph/test/vector_graph_cc.cpp

     
    77// http://www.boost.org/LICENSE_1_0.txt)
    88//=======================================================================
    99#include <boost/config.hpp>
     10#include <boost/concept/assert.hpp>
    1011#include <vector>
    1112#include <list>
    1213
    … …  
    2425  // Check "vector as graph"
    2526  {
    2627    typedef std::vector< std::list<int> > Graph;
    27     function_requires< VertexListGraphConcept<Graph> >();
    28     function_requires< IncidenceGraphConcept<Graph> >();
    29     function_requires< AdjacencyGraphConcept<Graph> >();
     28    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     29    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     30    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
    3031  }
    3132  return 0;
    3233}

  • libs/graph/test/test_properties.hpp

     
    77#ifndef TEST_PROPERTIES_HPP
    88#define TEST_PROPERTIES_HPP
    99
     10#include <boost/concept/assert.hpp>
     11
    1012template<typename T> T const& as_const(T& x) { return x; }
    1113template<typename T> void ignore(T const&) { }
    1214

  • libs/graph/test/test_destruction.hpp

     
    77#ifndef TEST_DESTRUCTION_HPP
    88#define TEST_DESTRUCTION_HPP
    99
     10#include <boost/concept/assert.hpp>
    1011#include <utility>
    1112
    1213/** @name Destroy Graph
    … …  
    3637void destroy_graph(Graph& g, VertexSet const&, boost::mpl::false_, boost::mpl::true_) {
    3738    using namespace boost;
    3839    BOOST_CONCEPT_ASSERT((VertexListGraphConcept<Graph>));
    39     // function_requires< VeretexMutableGraphConcept<Graph> >();
     40    // BOOST_CONCEPT_ASSERT(( VeretexMutableGraphConcept<Graph> ));
    4041
    4142    std::cout << "...destroy_labeled\n";
    4243    // Remove the roof vertex

  • libs/graph/test/test_direction.hpp

     
    99
    1010#include <algorithm>
    1111#include <boost/range.hpp>
     12#include <boost/concept/assert.hpp>
    1213
    1314/** @name Test Out-Directed Graph
    1415 * Test all graphs that have directed out edges.

  • libs/graph/test/reverse_graph_cc.cpp

     
    1010#include <boost/graph/graph_archetypes.hpp>
    1111#include <boost/graph/adjacency_list.hpp>
    1212#include <boost/graph/reverse_graph.hpp>
     13#include <boost/concept/assert.hpp>
    1314#include <string>
    1415
    1516int main(int,char*[])
    … …  
    2324      property<graph_name_t, std::string>
    2425    > AdjList;
    2526    typedef reverse_graph<AdjList> Graph;
    26     function_requires< VertexListGraphConcept<Graph> >();
     27    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    2728    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    2829    typedef graph_traits<Graph>::edge_descriptor Edge;
    29     function_requires< ReadablePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    30     function_requires< ReadablePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     30    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     31    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    3132    AdjList g;
    3233    Graph gr(g);
    3334    get_property(gr, graph_name_t());
    … …  
    4041      property<graph_name_t, std::string>
    4142    > AdjList;
    4243    typedef reverse_graph<AdjList,AdjList&> Graph;
    43     function_requires< VertexListGraphConcept<Graph> >();
     44    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
    4445    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    4546    typedef graph_traits<Graph>::edge_descriptor Edge;
    46     function_requires< PropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    47     function_requires< PropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     47    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     48    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    4849    AdjList g;
    4950    Graph gr(g);
    5051    get_property(gr, graph_name_t());

  • libs/graph/test/test_iteration.hpp

     
    77#ifndef TEST_ITERATION_HPP
    88#define TEST_ITERATION_HPP
    99
     10#include <boost/concept/assert.hpp>
    1011#include <algorithm>
    1112
    1213/** @name Test Vertex List

  • libs/graph/test/read_propmap.cpp

     
    66
    77#include <boost/graph/graph_concepts.hpp>
    88#include <boost/graph/adjacency_list.hpp>
     9#include <boost/concept/assert.hpp>
    910
    1011// Test contributed by Dmitry that validates a read-only property map bug
    1112// for bundled properties.
    … …  
    2425    typedef property_map<graph_t, double EdgeProp::*>::type WeightMap;
    2526    typedef property_map<graph_t, double EdgeProp::*>::const_type cWeightMap;
    2627    typedef graph_traits<graph_t>::edge_descriptor Edge;
    27     function_requires<ReadablePropertyMapConcept<WeightMap, Edge> >();
    28     function_requires<ReadablePropertyMapConcept<cWeightMap, Edge> >();
     28    BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept<WeightMap, Edge> ));
     29    BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept<cWeightMap, Edge> ));
    2930    return 0;
    3031}

  • libs/graph/test/adj_matrix_cc.cpp

     
    99#include <boost/graph/graph_concepts.hpp>
    1010#include <boost/graph/graph_archetypes.hpp>
    1111#include <boost/graph/adjacency_matrix.hpp>
     12#include <boost/concept/assert.hpp>
    1213
    1314int main(int,char*[])
    1415{
    … …  
    1617  // Check adjacency_matrix without properties
    1718  {
    1819    typedef adjacency_matrix<directedS> Graph;
    19     function_requires< VertexListGraphConcept<Graph> >();
    20     function_requires< EdgeListGraphConcept<Graph> >();
    21     function_requires< IncidenceGraphConcept<Graph> >();
    22     function_requires< AdjacencyGraphConcept<Graph> >();
    23     function_requires< MutableGraphConcept<Graph> >();
    24     function_requires< AdjacencyMatrixConcept<Graph> >();
     20    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     21    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     22    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     23    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     24    BOOST_CONCEPT_ASSERT(( MutableGraphConcept<Graph> ));
     25    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
    2526  }
    2627  {
    2728    typedef adjacency_matrix<undirectedS> Graph;
    28     function_requires< VertexListGraphConcept<Graph> >();
    29     function_requires< EdgeListGraphConcept<Graph> >();
    30     function_requires< IncidenceGraphConcept<Graph> >();
    31     function_requires< AdjacencyGraphConcept<Graph> >();
    32     function_requires< MutableGraphConcept<Graph> >();
    33     function_requires< AdjacencyMatrixConcept<Graph> >();
     29    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     30    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     31    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     32    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     33    BOOST_CONCEPT_ASSERT(( MutableGraphConcept<Graph> ));
     34    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
    3435  }
    3536  // Check adjacency_matrix with properties
    3637  {
    … …  
    3940      property<edge_weight_t, float> > Graph;
    4041    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    4142    typedef graph_traits<Graph>::edge_descriptor Edge;
    42     function_requires< VertexListGraphConcept<Graph> >();
    43     function_requires< EdgeListGraphConcept<Graph> >();
    44     function_requires< IncidenceGraphConcept<Graph> >();
    45     function_requires< AdjacencyGraphConcept<Graph> >();
    46     function_requires< AdjacencyMatrixConcept<Graph> >();
    47     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    48     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    49     function_requires< ReadablePropertyGraphConcept<Graph,
    50       Vertex, vertex_index_t> >();
    51     function_requires< PropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    52     function_requires< PropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     43    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     44    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     45    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     46    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     47    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
     48    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     49    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     50    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph,
     51      Vertex, vertex_index_t> ));
     52    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     53    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    5354  }
    5455  {
    5556    typedef adjacency_matrix<undirectedS,
    … …  
    5758      property<edge_weight_t, float> > Graph;
    5859    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    5960    typedef graph_traits<Graph>::edge_descriptor Edge;
    60     function_requires< VertexListGraphConcept<Graph> >();
    61     function_requires< EdgeListGraphConcept<Graph> >();
    62     function_requires< IncidenceGraphConcept<Graph> >();
    63     function_requires< AdjacencyGraphConcept<Graph> >();
    64     function_requires< AdjacencyMatrixConcept<Graph> >();
    65     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    66     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    67     function_requires< ReadablePropertyGraphConcept<Graph,
    68       Vertex, vertex_index_t> >();
    69     function_requires< PropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
    70     function_requires< PropertyGraphConcept<Graph, Edge, edge_weight_t> >();
     61    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     62    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
     63    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     64    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     65    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
     66    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     67    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     68    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph,
     69      Vertex, vertex_index_t> ));
     70    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
     71    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_weight_t> ));
    7172  }
    7273  return 0;
    7374}

  • libs/graph/test/edge_list_cc.cpp

     
    99#include <boost/graph/graph_concepts.hpp>
    1010#include <boost/graph/graph_archetypes.hpp>
    1111#include <boost/graph/edge_list.hpp>
     12#include <boost/concept/assert.hpp>
    1213#include <cstddef>
    1314#include <iterator>
    1415
    … …  
    2425   
    2526        typedef graph_traits<EdgeList>::edge_descriptor Edge;
    2627   
    27         function_requires< EdgeListGraphConcept<EdgeList> >();
     28        BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<EdgeList> ));
    2829   
    29         function_requires< ReadablePropertyGraphConcept<EdgeList, Edge,
    30             edge_index_t> >();
     30        BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<EdgeList, Edge,
     31            edge_index_t> ));
    3132    }
    3233    return 0;
    3334}

  • libs/graph/test/test_graph.hpp

     
    2020#include <utility>
    2121#include <vector>
    2222#include <boost/assert.hpp>
     23#include <boost/concept/assert.hpp>
    2324#include <boost/graph/graph_concepts.hpp>
    2425#include <boost/graph/graph_traits.hpp>
    2526#include <boost/graph/graph_mutability_traits.hpp>

  • libs/graph/test/stanford_graph_cc.cpp

     
    99#include <boost/graph/graph_concepts.hpp>
    1010#include <boost/graph/graph_archetypes.hpp>
    1111#include <boost/graph/stanford_graph.hpp>
     12#include <boost/concept/assert.hpp>
    1213
    1314int main(int,char*[])
    1415{
    … …  
    1819    typedef Graph* Graph;
    1920    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    2021    typedef graph_traits<Graph>::edge_descriptor Edge;
    21     function_requires< VertexListGraphConcept<Graph> >();
    22     function_requires< IncidenceGraphConcept<Graph> >();
    23     function_requires< AdjacencyGraphConcept<Graph> >();
    24     function_requires< PropertyGraphConcept<Graph, Edge, edge_length_t > >();
    25     function_requires<
    26       PropertyGraphConcept<Graph, Vertex, u_property<Vertex> > >();
    27     function_requires<
    28       PropertyGraphConcept<Graph, Edge, a_property<Vertex> > >();
     22    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     23    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     24    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     25    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_length_t > ));
     26    BOOST_CONCEPT_ASSERT((
     27      PropertyGraphConcept<Graph, Vertex, u_property<Vertex> > ));
     28    BOOST_CONCEPT_ASSERT((
     29      PropertyGraphConcept<Graph, Edge, a_property<Vertex> > ));
    2930  }
    3031  {
    3132    typedef const Graph* Graph;
    3233    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    3334    typedef graph_traits<Graph>::edge_descriptor Edge;
    34     function_requires< VertexListGraphConcept<Graph> >();
    35     function_requires< IncidenceGraphConcept<Graph> >();
    36     function_requires< AdjacencyGraphConcept<Graph> >();
    37     function_requires<
    38       ReadablePropertyGraphConcept<Graph, Edge, edge_length_t > >();
    39     function_requires<
    40       ReadablePropertyGraphConcept<Graph, Vertex, u_property<Vertex> > >();
    41     function_requires<
    42       ReadablePropertyGraphConcept<Graph, Edge, a_property<Vertex> > >();
     35    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     36    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     37    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     38    BOOST_CONCEPT_ASSERT((
     39      ReadablePropertyGraphConcept<Graph, Edge, edge_length_t > ));
     40    BOOST_CONCEPT_ASSERT((
     41      ReadablePropertyGraphConcept<Graph, Vertex, u_property<Vertex> > ));
     42    BOOST_CONCEPT_ASSERT((
     43      ReadablePropertyGraphConcept<Graph, Edge, a_property<Vertex> > ));
    4344  }
    4445  return 0;
    4546}

  • libs/graph/test/leda_graph_cc.cpp

     
    88//=======================================================================
    99#include <boost/graph/graph_concepts.hpp>
    1010#include <boost/graph/leda_graph.hpp>
     11#include <boost/concept/assert.hpp>
    1112
    12 
    1313int
    1414main(int,char*[])
    1515{
    … …  
    1818    typedef leda::GRAPH<int,int> Graph;
    1919    typedef graph_traits<Graph>::vertex_descriptor Vertex;
    2020    typedef graph_traits<Graph>::edge_descriptor Edge;
    21     function_requires< VertexListGraphConcept<Graph> >();
    22     function_requires< BidirectionalGraphConcept<Graph> >();
    23     function_requires< AdjacencyGraphConcept<Graph> >();
    24     function_requires< VertexMutableGraphConcept<Graph> >();
    25     function_requires< EdgeMutableGraphConcept<Graph> >();
    26     function_requires< VertexMutablePropertyGraphConcept<Graph> >();
    27     function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
    28     function_requires<
    29       ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
    30     function_requires<
    31       ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> >();
    32     function_requires<
    33       LvaluePropertyGraphConcept<Graph, Vertex, vertex_all_t> >();
    34     function_requires<
    35       LvaluePropertyGraphConcept<Graph, Vertex, edge_all_t> >();
     21    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     22    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
     23    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     24    BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept<Graph> ));
     25    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<Graph> ));
     26    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
     27    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
     28    BOOST_CONCEPT_ASSERT((
     29      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
     30    BOOST_CONCEPT_ASSERT((
     31      ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> ));
     32    BOOST_CONCEPT_ASSERT((
     33      LvaluePropertyGraphConcept<Graph, Vertex, vertex_all_t> ));
     34    BOOST_CONCEPT_ASSERT((
     35      LvaluePropertyGraphConcept<Graph, Vertex, edge_all_t> ));
    3636  }
    3737  return 0;
    3838}

  • libs/graph/doc/transitive_closure.w

     
    160160
    161161@d Concept checking
    162162@{
    163 function_requires< VertexListGraphConcept<Graph> >();
    164 function_requires< AdjacencyGraphConcept<Graph> >();
    165 function_requires< VertexMutableGraphConcept<GraphTC> >();
    166 function_requires< EdgeMutableGraphConcept<GraphTC> >();
    167 function_requires< ReadablePropertyMapConcept<VertexIndexMap, vertex> >();
     163BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     164BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     165BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept<GraphTC> ));
     166BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<GraphTC> ));
     167BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<VertexIndexMap, vertex> ));
    168168@}
    169169
    170170\noindent To simplify the code in the rest of the function we make the
    … …  
    566566  typedef typename graph_traits<G>::vertex_descriptor vertex;
    567567  typedef typename graph_traits<G>::vertex_iterator vertex_iterator;
    568568
    569   function_requires< AdjacencyMatrixConcept<G> >();
    570   function_requires< EdgeMutableGraphConcept<G> >();
     569  BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<G> ));
     570  BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<G> ));
    571571
    572572  // Matrix form:
    573573  // for k
    … …  
    597597  typedef typename graph_traits<G>::vertex_descriptor vertex;
    598598  typedef typename graph_traits<G>::vertex_iterator vertex_iterator;
    599599
    600   function_requires< AdjacencyMatrixConcept<G> >();
    601   function_requires< EdgeMutableGraphConcept<G> >();
     600  BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<G> ));
     601  BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<G> ));
    602602
    603603  // Make sure second loop will work 
    604604  if (num_vertices(g) == 0)
    … …  
    671671#include <boost/graph/topological_sort.hpp>
    672672#include <boost/graph/graph_concepts.hpp>
    673673#include <boost/graph/named_function_params.hpp>
     674#include <boost/concept/assert.hpp>
    674675
    675676namespace boost {
    676677

  • libs/graph/doc/BidirectionalGraph.html

     
    145145    typedef typename boost::graph_traits&lt;G&gt;::in_edge_iterator
    146146      in_edge_iterator;
    147147    void constraints() {
    148       function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
    149       function_requires&lt; MultiPassInputIteratorConcept&lt;in_edge_iterator&gt; &gt;();
     148      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
     149      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;in_edge_iterator&gt; ));
    150150
    151151      p = in_edges(v, g);
    152152      e = *p.first;

  • libs/graph/doc/AdjacencyGraph.html

     
    112112    typedef typename boost::graph_traits&lt;G&gt;::adjacency_iterator
    113113      adjacency_iterator;
    114114    void constraints() {
    115       function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
    116       function_requires&lt; MultiPassInputIteratorConcept&lt;adjacency_iterator&gt; &gt;();
     115      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
     116      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;adjacency_iterator&gt; ));
    117117
    118118      p = adjacent_vertices(v, g);
    119119      v = *p.first;

  • libs/graph/doc/IncidenceGraph.html

     
    162162  {
    163163    typedef typename boost::graph_traits&lt;G&gt;::out_edge_iterator out_edge_iterator;
    164164    void constraints() {
    165       function_requires&lt; GraphConcept&lt;G&gt; &gt;();
    166       function_requires&lt; MultiPassInputIteratorConcept&lt;out_edge_iterator&gt; &gt;();
     165      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
     166      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;out_edge_iterator&gt; ));
    167167
    168168      p = out_edges(u, g);
    169169      e = *p.first;

  • libs/graph/doc/MutablePropertyGraph.html

     
    125125  {
    126126    typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
    127127    void constraints() {
    128       function_requires&lt; MutableGraphConcept&lt;G&gt; &gt;();
     128      BOOST_CONCEPT_ASSERT(( MutableGraphConcept&lt;G&gt; ));
    129129      v = add_vertex(vp, g);
    130130      p = add_edge(u, v, ep, g);
    131131    }

  • libs/graph/doc/AStarHeuristic.html

     
    116116  struct AStarHeuristicConcept {
    117117    void constraints()
    118118    {
    119       function_requires&lt; CopyConstructibleConcept&lt;Heuristic&gt; &gt;();
     119      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept&lt;Heuristic&gt; ));
    120120      h(u);
    121121    }
    122122    Heuristic h;

  • libs/graph/doc/isomorphism-impl-v2.w

     
    388388@d Concept checking
    389389@{
    390390// Graph requirements
    391 function_requires< VertexListGraphConcept<Graph1> >();
    392 function_requires< EdgeListGraphConcept<Graph1> >();
    393 function_requires< VertexListGraphConcept<Graph2> >();
    394 function_requires< BidirectionalGraphConcept<Graph2> >();
     391BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
     392BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
     393BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
     394BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
    395395
    396396typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_t;
    397397typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
    398398typedef typename graph_traits<Graph1>::vertices_size_type size_type;
    399399
    400400// Vertex invariant requirement
    401 function_requires< AdaptableUnaryFunctionConcept<Invariant1,
    402   size_type, vertex1_t> >();
    403 function_requires< AdaptableUnaryFunctionConcept<Invariant2,
    404   size_type, vertex2_t> >();
     401BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant1,
     402  size_type, vertex1_t> ));
     403BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant2,
     404  size_type, vertex2_t> ));
    405405
    406406// Property map requirements
    407 function_requires< ReadWritePropertyMapConcept<IsoMapping, vertex1_t> >();
     407BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IsoMapping, vertex1_t> ));
    408408typedef typename property_traits<IsoMapping>::value_type IsoMappingValue;
    409409BOOST_STATIC_ASSERT((is_same<IsoMappingValue, vertex2_t>::value));
    410410
    411 function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
     411BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
    412412typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
    413413BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
    414414
    415 function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
     415BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
    416416typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
    417417BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
    418418@}

  • libs/graph/doc/Graph.html

     
    121121    typedef typename boost::graph_traits&lt;G&gt;::traversal_category traversal_category;
    122122
    123123    void constraints() {
    124       function_requires&lt; DefaultConstructibleConcept&lt;vertex_descriptor&gt; &gt;();
    125       function_requires&lt; EqualityComparableConcept&lt;vertex_descriptor&gt; &gt;();
    126       function_requires&lt; AssignableConcept&lt;vertex_descriptor&gt; &gt;();
    127       function_requires&lt; DefaultConstructibleConcept&lt;edge_descriptor&gt; &gt;();
    128       function_requires&lt; EqualityComparableConcept&lt;edge_descriptor&gt; &gt;();
    129       function_requires&lt; AssignableConcept&lt;edge_descriptor&gt; &gt;();
     124      BOOST_CONCEPT_ASSERT(( DefaultConstructibleConcept&lt;vertex_descriptor&gt; ));
     125      BOOST_CONCEPT_ASSERT(( EqualityComparableConcept&lt;vertex_descriptor&gt; ));
     126      BOOST_CONCEPT_ASSERT(( AssignableConcept&lt;vertex_descriptor&gt; ));
     127      BOOST_CONCEPT_ASSERT(( DefaultConstructibleConcept&lt;edge_descriptor&gt; ));
     128      BOOST_CONCEPT_ASSERT(( EqualityComparableConcept&lt;edge_descriptor&gt; ));
     129      BOOST_CONCEPT_ASSERT(( AssignableConcept&lt;edge_descriptor&gt; ));
    130130    }
    131131    G g;
    132132  };

  • libs/graph/doc/leda_conversion.html

     
    236236  main(int,char*[])
    237237  {
    238238    typedef GRAPH&lt;int,int&gt; Graph;
    239     function_requires&lt; VertexListGraphConcept&lt;Graph&gt; &gt;();
    240     function_requires&lt; BidirectionalGraphConcept&lt;Graph&gt; &gt;();
    241     function_requires&lt; MutableGraphConcept&lt;Graph&gt; &gt;();
     239    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;Graph&gt; ));
     240    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept&lt;Graph&gt; ));
     241    BOOST_CONCEPT_ASSERT(( MutableGraphConcept&lt;Graph&gt; ));
    242242    return 0;
    243243  }
    244244</PRE>

  • libs/graph/doc/isomorphism-impl-v3.w

     
    507507@d Concept checking
    508508@{
    509509// Graph requirements
    510 function_requires< VertexListGraphConcept<Graph1> >();
    511 function_requires< EdgeListGraphConcept<Graph1> >();
    512 function_requires< VertexListGraphConcept<Graph2> >();
    513 function_requires< BidirectionalGraphConcept<Graph2> >();
     510BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
     511BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
     512BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
     513BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
    514514
    515515typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_t;
    516516typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
    517517typedef typename graph_traits<Graph1>::vertices_size_type size_type;
    518518
    519519// Vertex invariant requirement
    520 function_requires< AdaptableUnaryFunctionConcept<Invariant1,
    521   size_type, vertex1_t> >();
    522 function_requires< AdaptableUnaryFunctionConcept<Invariant2,
    523   size_type, vertex2_t> >();
     520BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant1,
     521  size_type, vertex1_t> ));
     522BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant2,
     523  size_type, vertex2_t> ));
    524524
    525525// Property map requirements
    526 function_requires< ReadWritePropertyMapConcept<IsoMapping, vertex1_t> >();
     526BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IsoMapping, vertex1_t> ));
    527527typedef typename property_traits<IsoMapping>::value_type IsoMappingValue;
    528528BOOST_STATIC_ASSERT((is_same<IsoMappingValue, vertex2_t>::value));
    529529
    530 function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
     530BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
    531531typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
    532532BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
    533533
    534 function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
     534BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
    535535typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
    536536BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
    537537@}

  • libs/graph/doc/biconnected_components.w

     
    156156
    157157@d Concept checking of type parameters
    158158@{
    159 function_requires< VertexListGraphConcept<Graph> >();
    160 function_requires< IncidenceGraphConcept<Graph> >();
    161 function_requires< WritablePropertyMapConcept<ComponentMap, edge_t> >();
    162 function_requires< ReadWritePropertyMapConcept<DiscoverTimeMap, vertex_t> >();
    163 function_requires< ReadWritePropertyMapConcept<LowPointMap, vertex_t> >();
     159BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     160BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
     161BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, edge_t> ));
     162BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DiscoverTimeMap, vertex_t> ));
     163BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<LowPointMap, vertex_t> ));
    164164@}
    165165
    166166The first step of the algorithm is to initialize the discover times of
    … …  
    286286#include <boost/graph/graph_traits.hpp>
    287287#include <boost/graph/graph_concepts.hpp>
    288288#include <boost/property_map/property_map.hpp>
     289#include <boost/concept/assert.hpp>
    289290
    290291namespace boost {
    291292  @<Biconnected Components Algorithm@>

  • libs/graph/doc/VertexListGraph.html

     
    121121    typedef typename boost::graph_traits&lt;G&gt;::vertex_iterator
    122122      vertex_iterator;
    123123    void constraints() {
    124       function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
    125       function_requires&lt; AdjacencyGraphConcept&lt;G&gt; &gt;();
    126       function_requires&lt; MultiPassInputIteratorConcept&lt;vertex_iterator&gt; &gt;();
     124      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
     125      BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept&lt;G&gt; ));
     126      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;vertex_iterator&gt; ));
    127127
    128128      p = vertices(g);
    129129      V = num_vertices(g);

  • libs/graph/doc/VertexAndEdgeListGraph.html

     
    5151  struct VertexAndEdgeListGraphConcept
    5252  {
    5353    void constraints() {
    54       function_requires&lt; VertexListGraphConcept&lt;G&gt; &gt;();
    55       function_requires&lt; EdgeListGraphConcept&lt;G&gt; &gt;();
     54      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;G&gt; ));
     55      BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept&lt;G&gt; ));
    5656    }
    5757  };
    5858</PRE>

  • libs/graph/doc/PropertyGraph.html

     
    173173    typedef typename property_map&lt;G, PropertyTag&gt;::type Map;
    174174    typedef typename property_map&lt;G, PropertyTag&gt;::const_type const_Map;
    175175    void constraints() {
    176       function_requires&lt; GraphConcept&lt;G&gt; &gt;();
    177       function_requires&lt; ReadWritePropertyMapConcept&lt;Map, X&gt; &gt;();
    178       function_requires&lt; ReadablePropertyMapConcept&lt;const_Map, X&gt; &gt;();
     176      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
     177      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept&lt;Map, X&gt; ));
     178      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept&lt;const_Map, X&gt; ));
    179179
    180180      Map pmap = get(PropertyTag(), g);
    181181      pval = get(PropertyTag(), g, x);

  • libs/graph/doc/isomorphism-impl.w

     
    301301@d Concept checking
    302302@{
    303303// Graph requirements
    304 function_requires< VertexListGraphConcept<Graph1> >();
    305 function_requires< EdgeListGraphConcept<Graph1> >();
    306 function_requires< VertexListGraphConcept<Graph2> >();
    307 function_requires< BidirectionalGraphConcept<Graph2> >();
     304BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
     305BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
     306BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
     307BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
    308308
    309309// Property map requirements
    310 function_requires< ReadWritePropertyMapConcept<IndexMapping, vertex1_t> >();
     310BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IndexMapping, vertex1_t> ));
    311311typedef typename property_traits<IndexMapping>::value_type IndexMappingValue;
    312312BOOST_STATIC_ASSERT((is_same<IndexMappingValue, vertex2_t>::value));
    313313
    314 function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
     314BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
    315315typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
    316316BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
    317317
    318 function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
     318BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
    319319typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
    320320BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
    321321@}

  • libs/graph/doc/MutableGraph.html

     
    250250  struct MutableIncidenceGraphConcept
    251251  {
    252252    void constraints() {
    253       function_requires&lt; MutableGraph&lt;G&gt; &gt;();
     253      BOOST_CONCEPT_ASSERT(( MutableGraph&lt;G&gt; ));
    254254      remove_edge(iter, g);
    255255      remove_out_edge_if(u, p, g);
    256256    }
    … …  
    265265  struct MutableBidirectionalGraphConcept
    266266  {
    267267    void constraints() {
    268       function_requires&lt; MutableIncidenceGraph&lt;G&gt; &gt;();
     268      BOOST_CONCEPT_ASSERT(( MutableIncidenceGraph&lt;G&gt; ));
    269269      remove_in_edge_if(u, p, g);
    270270    }
    271271    G g;
    … …  
    278278  struct MutableEdgeListGraphConcept
    279279  {
    280280    void constraints() {
    281       function_requires&lt; MutableGraph&lt;G&gt; &gt;();
     281      BOOST_CONCEPT_ASSERT(( MutableGraph&lt;G&gt; ));
    282282      remove_edge_if(p, g);
    283283    }
    284284    G g;

  • libs/graph/doc/constructing_algorithms.html

     
    7979href="./VertexListGraph.html">VertexListGraph</a>. This is enforced by
    8080the use of those graph operations in the algorithm, and furthermore by
    8181our explicit requirement added as a concept check with
    82 <TT>function_requires()</TT> (see Section <A
     82<TT>BOOST_CONCEPT_ASSERT()</TT> (see Section <A
    8383HREF="../../concept_check/concept_check.htm">Concept
    8484Checking</A> for more details about concept checking).
    8585
    … …  
    122122    typedef typename property_traits&lt;Color&gt;::value_type ColorType;
    123123    typedef typename property_traits&lt;Order&gt;::value_type OrderType;
    124124
    125     function_requires&lt; VertexListGraphConcept&lt;VertexListGraph&gt; &gt;();
    126     function_requires&lt; ReadWritePropertyMapConcept&lt;Color, vertex_descriptor&gt; &gt;();
    127     function_requires&lt; IntegerConcept&lt;ColorType&gt; &gt;();
    128     function_requires&lt; ReadablePropertyMapConcept&lt;Order, size_type&gt; &gt;();
     125    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;VertexListGraph&gt; ));
     126    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept&lt;Color, vertex_descriptor&gt; ));
     127    BOOST_CONCEPT_ASSERT(( IntegerConcept&lt;ColorType&gt; ));
     128    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept&lt;Order, size_type&gt; ));
    129129    BOOST_STATIC_ASSERT((is_same&lt;OrderType, vertex_descriptor&gt;::value));
    130130   
    131131    size_type max_color = 0;

  • libs/graph/doc/EdgeListGraph.html

     
    146146    typedef typename boost::graph_traits&lt;G&gt;::edge_iterator
    147147      edge_iterator;
    148148    void constraints() {
    149       function_requires&lt; GraphConcept&lt;G&gt; &gt;();
    150       function_requires&lt; MultiPassInputIteratorConcept&lt;edge_iterator&gt; &gt;();
     149      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
     150      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;edge_iterator&gt; ));
    151151
    152152      p = edges(g);
    153153      E = num_edges(g);

  • libs/graph/doc/KeyedUpdatableQueue.html

     
    6363    typedef typename Q::key_map key_map;
    6464   
    6565    void constraints() {
    66       function_requires&lt; UpdatableQueue&lt;Q&gt; &gt;();
    67       function_requires&lt; ReadWritePropertyMap&lt; key_map, typename Buffer&lt;Q&gt;::value_type &gt; &gt;();
     66      BOOST_CONCEPT_ASSERT(( UpdatableQueue&lt;Q&gt; ));
     67      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMap&lt; key_map, typename Buffer&lt;Q&gt;::value_type &gt; ));
    6868    }
    6969   
    7070    void const_constraints(const Q&amp; cq) {

  • libs/graph/doc/UpdatableQueue.html

     
    5858  struct UpdatableQueueConcept
    5959  {
    6060    void constraints() {
    61       function_requires&lt; Buffer&lt;Q&gt; &gt;();
     61      BOOST_CONCEPT_ASSERT(( Buffer&lt;Q&gt; ));
    6262     
    6363      q.update(g_ct);
    6464    }

  • libs/graph/example/implicit_graph.cpp

     
    44//    (See accompanying file LICENSE_1_0.txt or copy at
    55//          http://www.boost.org/LICENSE_1_0.txt)
    66
    7 
     7#include <boost/concept/assert.hpp>
    88#include <boost/graph/adjacency_iterator.hpp>
    99#include <boost/graph/dijkstra_shortest_paths.hpp>
    1010#include <boost/graph/graph_concepts.hpp>
    … …  
    444444  // Check the concepts that graph models.  This is included to demonstrate
    445445  // how concept checking works, but is not required for a working program
    446446  // since Boost algorithms do their own concept checking.
    447   function_requires< BidirectionalGraphConcept<ring_graph> >();
    448   function_requires< AdjacencyGraphConcept<ring_graph> >();
    449   function_requires< VertexListGraphConcept<ring_graph> >();
    450   function_requires< EdgeListGraphConcept<ring_graph> >();
    451   function_requires< AdjacencyMatrixConcept<ring_graph> >();
    452   function_requires<
    453     ReadablePropertyMapConcept<const_edge_weight_map, edge_descriptor> >();
    454   function_requires<
    455     ReadablePropertyGraphConcept<ring_graph, edge_descriptor, edge_weight_t> >();
     447  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<ring_graph> ));
     448  BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<ring_graph> ));
     449  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<ring_graph> ));
     450  BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<ring_graph> ));
     451  BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<ring_graph> ));
     452  BOOST_CONCEPT_ASSERT((
     453    ReadablePropertyMapConcept<const_edge_weight_map, edge_descriptor> ));
     454  BOOST_CONCEPT_ASSERT((
     455    ReadablePropertyGraphConcept<ring_graph, edge_descriptor, edge_weight_t> ));
    456456
    457457  // Specify the size of the graph on the command line, or use a default size
    458458  // of 5.

  • libs/graph/example/put-get-helper-eg.cpp

     
    88#include <vector>
    99#include <string>
    1010#include <boost/property_map/property_map.hpp>
     11#include <boost/concept/assert.hpp>
    1112
    1213#ifdef BOOST_NO_STD_ITERATOR_TRAITS
    1314#error This examples requires a compiler that provides a working std::iterator_traits
    … …  
    5354  typedef foo::iterator_property_map < vec_t::iterator,
    5455    boost::identity_property_map > pmap_t;
    5556  using namespace boost;
    56   function_requires < Mutable_LvaluePropertyMapConcept < pmap_t, int > >();
     57  BOOST_CONCEPT_ASSERT(( Mutable_LvaluePropertyMapConcept<pmap_t, int> ));
    5758  return 0;
    5859}

  • libs/graph/example/loops_dfs.cpp

     
    66// http://www.boost.org/LICENSE_1_0.txt)
    77//=======================================================================
    88#include <boost/config.hpp>
     9#include <boost/concept/assert.hpp>
    910#include <iostream>
    1011#include <fstream>
    1112#include <stack>
    … …  
    4748           const Graph & g,
    4849           Loops & loops)    // A container of sets of vertices
    4950{
    50   function_requires < BidirectionalGraphConcept < Graph > >();
     51  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
    5152  typedef typename graph_traits < Graph >::edge_descriptor Edge;
    5253  typedef typename graph_traits < Graph >::vertex_descriptor Vertex;
    5354  std::vector < Edge > back_edges;
    … …  
    6970                    Graph >::edge_descriptor back_edge, const Graph & g,
    7071                    Set & loop_set)
    7172{
    72   function_requires < BidirectionalGraphConcept < Graph > >();
     73  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
    7374  typedef typename graph_traits < Graph >::vertex_descriptor Vertex;
    7475  typedef color_traits < default_color_type > Color;
    7576

  • libs/graph/example/leda-concept-check.cpp

     
    77//=======================================================================
    88#include <boost/graph/graph_concepts.hpp>
    99#include <boost/graph/leda_graph.hpp>
     10#include <boost/concept/assert.hpp>
    1011
    1112int
    1213main()
    1314{
    1415  using namespace boost;
    15   typedef leda::GRAPH < int, int >Graph;
    16   function_requires < VertexListGraphConcept < Graph > >();
    17   function_requires < BidirectionalGraphConcept < Graph > >();
    18   function_requires < VertexMutableGraphConcept < Graph > >();
    19   function_requires < EdgeMutableGraphConcept < Graph > >();
     16  typedef leda::GRAPH<int, int> Graph;
     17  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     18  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept< Graph> ));
     19  BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept< Graph> ));
     20  BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<Graph> ));
    2021  return EXIT_SUCCESS;
    2122}

  • libs/concept_check/reference.htm

     
    366366void function_requires();
    367367</pre>
    368368
     369  <p><code>function_requires()</code> has been deprecated in favor of <code>BOOST_CONCEPT_ASSERT</code>.
     370   This means that <del><code>function_requires< Concept<Type> >();</code></del>
     371   becomes <code>BOOST_CONCEPT_ASSERT((Concept<Type>));</code>
     372   (don't forget to <code>#include &quot;boost/concept/assert.hpp&quot;</code>).
     373
     374
    369375  <h3><a name="deprecated-macros" id="deprecated-macros">Deprecated
    370376  Macros</a></h3>
    371377  <pre>