boost/graph/graph_archetypes.hpp   |  247 ++++++++++++++++++++++++++++++++++++
 libs/graph/test/graph_concepts.cpp |   16 +++
 2 files changed, 263 insertions(+)

diff --git a/boost/graph/graph_archetypes.hpp b/boost/graph/graph_archetypes.hpp
index 81f9c2c..f4a8e34 100644
--- a/boost/graph/graph_archetypes.hpp
+++ b/boost/graph/graph_archetypes.hpp
@@ -187,7 +187,254 @@ namespace boost { // should use a different namespace for this
   }
 
   //===========================================================================
+  template <typename Vertex, typename Directed, typename ParallelCategory,
+    typename Base = detail::null_graph_archetype >
+  struct edge_list_graph_archetype : public Base
+  {
+    typedef typename Base::traversal_category base_trav_cat;
+    struct traversal_category
+      : public edge_list_graph_tag, public base_trav_cat { };
+
+    typedef Vertex vertex_descriptor;
+    typedef unsigned int edges_size_type;
+    typedef Directed directed_category;
+    typedef ParallelCategory edge_parallel_category;
+
+    struct edge_descriptor {
+      edge_descriptor() { }
+      edge_descriptor(const detail::dummy_constructor&) { }
+      bool operator==(const edge_descriptor&) const { return false; }
+      bool operator!=(const edge_descriptor&) const { return false; }
+    };
+    typedef input_iterator_archetype<edge_descriptor> edge_iterator;
+
+    static vertex_descriptor null_vertex() {return vertex_descriptor();}
+  };
+  
+  template <typename V, typename D, typename P, typename B>
+  std::pair<typename edge_list_graph_archetype<V,D,P,B>::edge_iterator,
+            typename edge_list_graph_archetype<V,D,P,B>::edge_iterator>
+  edges(const edge_list_graph_archetype<V,D,P,B>& )
+  {
+    typedef typename edge_list_graph_archetype<V,D,P,B>::edge_iterator Iter;
+    return std::make_pair(Iter(), Iter());
+  }
+
+  template <typename V, typename D, typename P, typename B>
+  typename edge_list_graph_archetype<V,D,P,B>::edges_size_type
+  num_edges(const edge_list_graph_archetype<V,D,P,B>& )
+  {
+    return 0;
+  }
+
+  template <typename V, typename D, typename P, typename B>
+  V source(const typename edge_list_graph_archetype<V,D,P,B>::edge_descriptor&,
+           const edge_list_graph_archetype<V,D,P,B>& )
+  {
+    return V(static_object<detail::dummy_constructor>::get());
+  }
+
+  template <typename V, typename D, typename P, typename B>
+  V target(const typename edge_list_graph_archetype<V,D,P,B>::edge_descriptor&,
+           const edge_list_graph_archetype<V,D,P,B>& )
+  {
+    return V(static_object<detail::dummy_constructor>::get());
+  }
+
+  //===========================================================================
+  template <typename Vertex, typename Directed, typename ParallelCategory,
+    typename Base = detail::null_graph_archetype >
+  struct vertex_and_edge_list_graph_archetype : public Base
+  {
+    typedef typename Base::traversal_category base_trav_cat;
+    struct traversal_category
+      : public vertex_list_graph_tag, 
+        public edge_list_graph_tag, 
+        public base_trav_cat { };
+
+    typedef vertex_list_graph_archetype<Vertex, Directed, ParallelCategory> 
+      VertexList;
+    typedef edge_list_graph_archetype<Vertex, Directed, ParallelCategory> 
+      EdgeList;
+
+    typedef Directed directed_category;
+    typedef ParallelCategory edge_parallel_category;
+
+    typedef Vertex vertex_descriptor;
+
+    typedef typename VertexList::out_edge_iterator out_edge_iterator;
+    typedef typename VertexList::adjacency_iterator adjacency_iterator;
+
+    typedef typename VertexList::vertices_size_type vertices_size_type;
+    typedef typename VertexList::vertex_iterator vertex_iterator;
+
+    typedef typename EdgeList::edge_descriptor edge_descriptor;
+    typedef typename EdgeList::edge_iterator edge_iterator;
+    typedef typename EdgeList::edges_size_type edges_size_type;
+
+    static vertex_descriptor null_vertex() {return vertex_descriptor();}
+  };
+
+  template <typename V, typename D, typename P, typename B>
+  std::pair<typename vertex_and_edge_list_graph_archetype<V,D,P,B>::vertex_iterator,
+            typename vertex_and_edge_list_graph_archetype<V,D,P,B>::vertex_iterator>
+  vertices(const vertex_and_edge_list_graph_archetype<V,D,P,B>& )
+  {
+    typedef typename vertex_and_edge_list_graph_archetype<V,D,P,B>::vertex_iterator Iter;
+    return std::make_pair(Iter(), Iter());
+  }
+
+  template <typename V, typename D, typename P, typename B>
+  typename vertex_and_edge_list_graph_archetype<V,D,P,B>::vertices_size_type
+  num_vertices(const vertex_and_edge_list_graph_archetype<V,D,P,B>& )
+  {
+    return 0;
+  }
+
+  template <typename V, typename D, typename P, typename B>
+  typename vertex_and_edge_list_graph_archetype<V,D,P,B>::degree_size_type
+  out_degree(const V&, const vertex_and_edge_list_graph_archetype<V,D,P,B>& )
+  {
+    return 0;
+  }
+
+  template <typename V, typename D, typename P, typename B>
+  std::pair<typename vertex_and_edge_list_graph_archetype<V,D,P,B>::edge_iterator,
+            typename vertex_and_edge_list_graph_archetype<V,D,P,B>::edge_iterator>
+  edges(const vertex_and_edge_list_graph_archetype<V,D,P,B>& )
+  {
+    typedef typename vertex_and_edge_list_graph_archetype<V,D,P,B>::edge_iterator Iter;
+    return std::make_pair(Iter(), Iter());
+  }
+
+  template <typename V, typename D, typename P, typename B>
+  typename vertex_and_edge_list_graph_archetype<V,D,P,B>::edges_size_type
+  num_edges(const vertex_and_edge_list_graph_archetype<V,D,P,B>& )
+  {
+    return 0;
+  }
 
+  template <typename V, typename D, typename P, typename B>
+  V source(const typename vertex_and_edge_list_graph_archetype<V,D,P,B>::edge_descriptor&,
+           const vertex_and_edge_list_graph_archetype<V,D,P,B>& )
+  {
+    return V(static_object<detail::dummy_constructor>::get());
+  }
+
+  template <typename V, typename D, typename P, typename B>
+  V target(const typename vertex_and_edge_list_graph_archetype<V,D,P,B>::edge_descriptor&,
+           const vertex_and_edge_list_graph_archetype<V,D,P,B>& )
+  {
+    return V(static_object<detail::dummy_constructor>::get());
+  }
+
+  //===========================================================================
+  template <typename Vertex, typename Directed, typename ParallelCategory,
+    typename Base = detail::null_graph_archetype >
+  struct adjacency_matrix_archetype : public Base
+  {
+    typedef typename Base::traversal_category base_trav_cat;
+    struct traversal_category
+      : public adjacency_matrix_tag, public base_trav_cat { };
+    typedef Vertex vertex_descriptor;
+    struct edge_descriptor {
+      edge_descriptor() { }
+      edge_descriptor(const detail::dummy_constructor&) { }
+      bool operator==(const edge_descriptor&) const { return false; }
+      bool operator!=(const edge_descriptor&) const { return false; }
+    };
+
+    typedef Directed directed_category;
+    typedef ParallelCategory edge_parallel_category;
+
+    static vertex_descriptor null_vertex() {return vertex_descriptor();}
+  };
+  
+  template <typename V, typename D, typename P, typename B>
+  std::pair<typename adjacency_matrix_archetype<V,D,P,B>::edge_descriptor,
+            bool>
+  edge(const V&, const V&, const adjacency_matrix_archetype<V,D,P,B>& )
+  {
+    typedef typename adjacency_matrix_archetype<V,D,P,B>::edge_descriptor Descriptor;
+    return std::make_pair(Descriptor(), bool());
+  }
+
+  //===========================================================================
+  template <typename Vertex, typename ParallelCategory,
+    typename Base = detail::null_graph_archetype >
+  struct bidirectional_graph_archetype : public Base
+  {
+    typedef incidence_graph_archetype<Vertex, bidirectional_tag, ParallelCategory> 
+      Incidence;
+
+    typedef typename Base::traversal_category base_trav_cat;
+    struct traversal_category
+      : public bidirectional_graph_tag, public base_trav_cat { };
+
+    typedef Vertex vertex_descriptor;
+    typedef typename Incidence::degree_size_type degree_size_type;
+    typedef typename Incidence::edge_descriptor edge_descriptor;
+    typedef typename Incidence::out_edge_iterator out_edge_iterator;
+    typedef input_iterator_archetype<edge_descriptor> in_edge_iterator;
+
+    typedef bidirectional_tag directed_category;
+    typedef ParallelCategory edge_parallel_category;
+
+    static vertex_descriptor null_vertex() {return vertex_descriptor();}
+  };
+  template <typename V, typename P, typename B>
+  V source(const typename bidirectional_graph_archetype<V,P,B>::edge_descriptor&,
+           const bidirectional_graph_archetype<V,P,B>& )
+  {
+    return V(static_object<detail::dummy_constructor>::get());
+  }
+  template <typename V, typename P, typename B>
+  V target(const typename bidirectional_graph_archetype<V,P,B>::edge_descriptor&,
+           const bidirectional_graph_archetype<V,P,B>& )
+  {
+    return V(static_object<detail::dummy_constructor>::get());
+  }
+  
+  template <typename V, typename P, typename B>
+  std::pair<typename bidirectional_graph_archetype<V,P,B>::out_edge_iterator,
+            typename bidirectional_graph_archetype<V,P,B>::out_edge_iterator>
+  out_edges(const V&, const bidirectional_graph_archetype<V,P,B>& )
+  {
+    typedef typename bidirectional_graph_archetype<V,P,B>::out_edge_iterator Iter;
+    return std::make_pair(Iter(), Iter());
+  }
+  
+  template <typename V, typename P, typename B>
+  typename bidirectional_graph_archetype<V,P,B>::degree_size_type
+  out_degree(const V&, const bidirectional_graph_archetype<V,P,B>& )
+  {
+    return 0;
+  }
+
+  template <typename V, typename P, typename B>
+  std::pair<typename bidirectional_graph_archetype<V,P,B>::in_edge_iterator,
+            typename bidirectional_graph_archetype<V,P,B>::in_edge_iterator>
+  in_edges(const V&, const bidirectional_graph_archetype<V,P,B>& )
+  {
+    typedef typename bidirectional_graph_archetype<V,P,B>::in_edge_iterator Iter;
+    return std::make_pair(Iter(), Iter());
+  }
+  
+  template <typename V, typename P, typename B>
+  typename bidirectional_graph_archetype<V,P,B>::degree_size_type
+  in_degree(const V&, const bidirectional_graph_archetype<V,P,B>& )
+  {
+    return 0;
+  }
+
+  template <typename V, typename P, typename B>
+  typename bidirectional_graph_archetype<V,P,B>::degree_size_type
+  degree(const V&, const bidirectional_graph_archetype<V,P,B>& )
+  {
+    return 0;
+  }
+
+  //===========================================================================
   struct property_graph_archetype_tag { };
 
   template <typename GraphArchetype, typename Property, typename ValueArch>
diff --git a/libs/graph/test/graph_concepts.cpp b/libs/graph/test/graph_concepts.cpp
index c2edc34..c728732 100644
--- a/libs/graph/test/graph_concepts.cpp
+++ b/libs/graph/test/graph_concepts.cpp
@@ -37,5 +37,21 @@ int main(int,char*[])
     Graph4;
   BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph4, Vertex, vertex_color_t> ));
 
+  typedef edge_list_graph_archetype<Vertex, directed_tag, 
+    allow_parallel_edge_tag> Graph5;
+  BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph5> ));
+
+  typedef vertex_and_edge_list_graph_archetype<Vertex, directed_tag, 
+    allow_parallel_edge_tag> Graph6;
+  BOOST_CONCEPT_ASSERT(( VertexAndEdgeListGraphConcept<Graph6> ));
+
+  typedef adjacency_matrix_archetype<Vertex, directed_tag, 
+    allow_parallel_edge_tag> Graph7;
+  BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph7> ));
+
+  typedef bidirectional_graph_archetype<Vertex,
+    allow_parallel_edge_tag> Graph8;
+  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph8> ));
+
   return 0;
 }