Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_34_1/libs/graph/doc/subgraph.html @ 29

Last change on this file since 29 was 29, checked in by landauf, 17 years ago
updated boost from 1_33_1 to 1_34_1
File size: 21.4 KB

Line
1	<HTML>
2	<!--
3	-- Copyright (c) Jeremy Siek 2000
4	--
5	-- Distributed under the Boost Software License, Version 1.0.
6	-- (See accompanying file LICENSE_1_0.txt or copy at
7	-- http://www.boost.org/LICENSE_1_0.txt)
8	-->
9	<Head>
10	<Title>Boost Graph Library: Subgraph</Title>
11	<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b"
12	ALINK="#ff0000">
13	<IMG SRC="../../../boost.png"
14	ALT="C++ Boost" width="277" height="86">
15
16	<BR Clear>
17
18	<H1><A NAME="sec:subgraph-class"></A>
19	<pre>
20	subgraph<Graph>
21	</pre>
22	</h1>
23
24	<!--The space consumption of the <tt>subgraph</tt> is quite high.
25	We should change subgraph from representing induced subgraphs to just
26	normal subgraphs (from talk with Steven North). -->
27
28	<p>
29	The subgraph class provides a mechanism for keeping track of a graph
30	and its subgraphs. A graph <i>G'</i> is a <i>subgraph</i> of a graph
31	<i>G</i> if the vertex set of <i>G'</i> is a subset of the vertex set
32	of <i>G</i> and if the edge set of <i>G'</i> is a subset of the edge
33	set of <i>G</i>. That is, if <i>G'=(V',E')</i> and <i>G=(V,E)</i>,
34	then <i>G'</i> is a subgraph of <i>G</i> if <i>V'</i> is a subset of
35	<i>V</i> and <i>E</i> is a subset of <i>E'</i>. An <i>induced
36	subgraph</i> is a subgraph formed by specifying a set of vertices
37	<i>V'</i> and then selecting all of the edges from the original graph
38	that connect two vertices in <i>V'</i>. So in this case <i>E' = {(u,v)
39	in E: u,v in V'}</i>. Figure 1 shows a graph <i>G<sub>0</sub></i> and
40	two subgraphs <i>G<sub>1</sub></i> and <i>G<sub>2</sub></i>. The edge
41	set for <i>G<sub>1</sub></i> is <i>E<sub>1</sub> = { (E,F), (C,F)
42	}</i> and the edge set for <i>G<sub>2</sub></i> is <i>E<sub>2</sub> =
43	{ (A,B) }</i>. Edges such as <i>(E,B)</i> and <i>(F,D)</i> that cross
44	out of a subgraph are not in the edge set of the subgraph.
45	</p>
46
47	<P></P>
48	<DIV ALIGN="center"><A NAME="fig:subgraph-tree"></A>
49	<TABLE>
50	<CAPTION ALIGN="BOTTOM"><STRONG>Figure 1:</STRONG> A graph with nested subgraphs, maintained in a tree structure.</CAPTION>
51	<TR><TD><IMG SRC="./figs/subgraph.gif"></TD>
52	<TD><IMG SRC="./figs/subgraph-tree.gif"></TD></TR>
53	</TABLE>
54	</DIV><P></P>
55
56	<p>The <tt>subgraph</tt> class implements induced subgraphs. The main graph
57	and its subgraphs are maintained in a tree data structure. The main
58	graph is the root, and subgraphs are either children of the root or of
59	other subgraphs. All of the nodes in this tree, including the root
60	graph, are instances of the <tt>subgraph</tt> class. The
61	<tt>subgraph</tt> implementation ensures that each node in the tree is
62	an induced subgraph of its parent. The <tt>subgraph</tt> class
63	implements the BGL graph interface, so each subgraph object can be
64	treated as a graph.</p>
65
66	<h3>Example</h3>
67
68	The full source code for this example is in
69	<tt>example/subgraph.cpp</tt>. To create a graph and subgraphs, first
70	create the root graph object. Here we use <tt>adjacency_list</tt> as
71	the underlying graph implementation. The underlying graph type is
72	required to have <tt>vertex_index</tt> and <tt>edge_index</tt>
73	internal properties, so we add an edge index property to the adjacency
74	list. We do not need to add a vertex index properety because that is
75	built in to the <tt>adjacency_list</tt>. We will be building the graph
76	and subgraphs in Figure 1, so we will need a total of six vertices.
77
78	<pre>
79	typedef adjacency_list_traits<vecS, vecS, directedS> Traits;
80	typedef subgraph< adjacency_list<vecS, vecS, directedS,
81	no_property, property<edge_index_t, int> > > Graph;
82
83	const int N = 6;
84	Graph G0(N);
85
86	enum { A, B, C, D, E, F}; // for conveniently refering to vertices in G0
87	</pre>
88
89	Next we create two empty subgraph objects, specifying <tt>G0</tt> as
90	their parent.
91
92	<pre>
93	Graph& G1 = G0.create_subgraph(), G2 = G0.create_subgraph();
94	enum { A1, B1, C2 }; // for conveniently refering to vertices in G1
95	enum { A2, B2 }; // for conveniently refering to vertices in G2
96	</pre>
97
98	We can add vertices from the root graph to the subgraphs using the
99	<tt>add_vertex</tt> function. Since the graph implementation is
100	<tt>adjacency_list</tt> with <tt>VertexList=vecS</tt>, we can use the
101	integers (or in this case enums) in the range <i>[0,6)</i> as vertex
102	descriptors.
103
104	<pre>
105	add_vertex(C, G1); // global vertex C becomes local A1 for G1
106	add_vertex(E, G1); // global vertex E becomes local B1 for G1
107	add_vertex(F, G1); // global vertex F becomes local C1 for G1
108
109	add_vertex(A, G2); // global vertex A becomes local A2 for G2
110	add_vertex(B, G2); // global vertex B becomes local B2 for G2
111	</pre>
112
113	Next we can add edges to the main graph using the usual
114	<tt>add_edge</tt> function.
115
116	<pre>
117	add_edge(A, B, G0);
118	add_edge(B, C, G0);
119	add_edge(B, D, G0);
120	add_edge(E, B, G0);
121	add_edge(E, F, G0);
122	add_edge(F, D, G0);
123	</pre>
124
125	We can also add edges to subgraphs such as <tt>G1</tt> using the
126	<tt>add_edge</tt> function. Each subgraph has its own vertex and edge
127	descriptors, which we call <i>local</i> descriptors. We refer to root
128	graph's vertex and edge descriptors as the <i>global</i>
129	descriptors. Above, we used global vertex descriptors to add vertices
130	to the graph. However, most <tt>subgraph</tt> functions work with
131	local descriptors. So in the following call to <tt>add_edge</tt> we
132	add the edge <tt>(A1,C1)</tt> (or numerically <tt>(0,2)</tt>) which is
133	the local version (for subgraph <tt>G1</tt>) of the global edge
134	<tt>(C,F)</tt> (or numerically <tt>(2,5)</tt>). Adding an edge to a
135	subgraph causes the edge to also be added to all of its ancestors in
136	the subgraph tree to ensure that the subgraph property is maintained.
137
138	<pre>
139	add_edge(A1, C1, G1); // (A1,C1) is subgraph G1 local indices
140	// for the global edge (C,F).
141	</pre>
142
143	<!----------------------------->
144	<h3>Where Defined</h3>
145
146	<tt>boost/graph/subgraph.hpp</tt>
147
148	<!----------------------------->
149	<h3>Template Parameters</h3>
150
151	<P>
152	<TABLE border>
153	<TR>
154	<th>Parameter</th><th>Description</th>
155	</tr>
156	<tr><td><tt>Graph</tt> </td>
157	<td> A graph type modeling <a href="VertexMutableGraph.html">VertexMutableGraph</a>
158	and <a href="EdgeMutableGraph.html">EdgeMutableGraph</a>. Also
159	the graph must have internal <tt>vertex_index</tt> and
160	<tt>edge_index</tt> properties. The vertex indices must be maintained
161	automatically by the graph, whereas the edge indices will be
162	assigned by the <tt>subgraph</tt> class implementation. </td>
163	</tr>
164	</table>
165
166
167	<!----------------------------->
168	<h3>Model Of</h3>
169
170	<tt>subgraph</tt> is a model of <a href="VertexMutableGraph.html">VertexMutableGraph</a>. Also, if
171	the <tt>Graph</tt> type models <a href="VertexListGraph.html">VertexListGraph</a>,
172	<a href="EdgeListGraph.html">EdgeListGraph</a> and/or <a href="BidirectionalGraph.html">BidirectionalGraph</a>, then
173	<tt>subgraph<Graph></tt> will also models these concepts.
174
175	<!----------------------------->
176	<h3>Associates Types</h3>
177
178	If the graph is the root of the subgraph tree, then the vertex and
179	edge descriptors are both the local descriptors for the root graph,
180	and they are the global descriptors. If the graph is not the root,
181	then the descriptors are local descriptors for the subgraph.
182	The subgraph iterators are the same iterator types as the iterators of
183	the underlying <tt>Graph</tt> type.
184
185	<hr>
186
187	<pre>
188	graph_traits<subgraph>::vertex_descriptor
189	</pre>
190	The type for the vertex descriptors.
191	(Required by <a href="Graph.html">Graph</a>.)
192
193	<hr>
194
195	<pre>
196	graph_traits<subgraph>::edge_descriptor
197	</pre>
198	The type for the edge descriptors.
199	(Required by <a href="Graph.html">Graph</a>.)
200
201	<hr>
202
203	<pre>
204	graph_traits<subgraph>::vertex_iterator
205	</pre>
206	The type for the iterators returned by <tt>vertices</tt>.
207	(Required by <a href="VertexListGraph.html">VertexListGraph</a>.)
208
209	<hr>
210
211	<pre>
212	graph_traits<subgraph>::edge_iterator
213	</pre>
214	The type for the iterators returned by <tt>edges</tt>.
215	(Required by <a href="EdgeListGraph.html">EdgeListGraph</a>.)
216
217	<hr>
218	<pre>
219	graph_traits<subgraph>::out_edge_iterator
220	</pre>
221	The type for the iterators returned by <tt>out_edges</tt>.
222	(Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
223
224	<hr>
225	<pre>
226	graph_traits<subgraph>::in_edge_iterator
227	</pre>
228	The <tt>in_edge_iterator</tt> is the
229	iterator type returned by the <tt>in_edges</tt> function.
230	(Required by <a href="BidirectionalGraph.html">BidirectionalGraph</a>.)
231
232	<hr>
233	<pre>
234	graph_traits<subgraph>::adjacency_iterator
235	</pre>
236	The type for the iterators returned by <tt>adjacent_vertices</tt>.
237	(Required by <a href="AdjacencyGraph.html">AdjacencyGraph</a>.)
238
239	<hr>
240	<pre>
241	graph_traits<subgraph>::directed_category
242	</pre>
243	Provides information about whether the graph is directed
244	(<tt>directed_tag</tt>) or undirected (<tt>undirected_tag</tt>).
245	(Required by <a href="Graph.html">Graph</a>.)
246
247	<hr>
248	<pre>
249	graph_traits<subgraph>::edge_parallel_category
250	</pre>
251	This describes whether the graph class allows the insertion of
252	parallel edges (edges with the same source and target), which
253	depends on the underlying <tt>Graph</tt> class. The two tags are
254	<tt>allow_parallel_edge_tag</tt> and
255	<tt>disallow_parallel_edge_tag</tt>.
256	(Required by <a href="Graph.html">Graph</a>.)
257
258	<hr>
259	<pre>
260	graph_traits<subgraph>::vertices_size_type
261	</pre>
262	The type used for dealing with the number of vertices in
263	the graph.
264	(Required by <a href="VertexListGraph.html">VertexListGraph</a>.)
265
266	<hr>
267	<pre>
268	graph_traits<subgraph>::edges_size_type
269	</pre>
270	The type used for dealing with the number of edges in the graph.
271	(Required by <a href="EdgeListGraph.html">EdgeListGraph</a>.)
272
273	<hr>
274	<pre>
275	graph_traits<subgraph>::degree_size_type
276	</pre>
277	The type used for dealing with the number of out-edges of a vertex.
278	(Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
279
280	<hr>
281	<pre>
282	property_map<subgraph, PropertyTag>::type
283	property_map<subgraph, PropertyTag>::const_type
284	</pre>
285	The map type for vertex or edge properties in the graph. The
286	specific property is specified by the <tt>PropertyTag</tt> template
287	argument, and must match one of the properties specified in the
288	<tt>VertexProperty</tt> or <tt>EdgeProperty</tt> for the graph.
289	(Required by <a href="PropertyGraph.html">PropertyGraph</a>.)
290
291	<hr>
292	<pre>
293	subgraph::children_iterator
294	</pre>
295	The iterator type for accessing the children subgraphs of the graph.
296
297
298
299	<!----------------------------->
300	<h3>Member Functions</h3>
301
302
303
304	<hr>
305	<pre>
306	subgraph(vertices_size_type n, const GraphProperty& p = GraphProperty())
307	</pre>
308	Creates the root graph object with <tt>n</tt> vertices and zero edges.
309
310	<hr>
311	<pre>
312	subgraph<Graph>& create_subgraph();
313	</pre>
314	Creates an empty subgraph object whose parent is <i>this</i>
315	graph.
316
317	<hr>
318	<pre>
319	template <typename VertexIterator>
320	subgraph<Graph>&
321	create_subgraph(VertexIterator first, VertexIterator last)
322	</pre>
323	Creates a subgraph object with the specified vertex set. The
324	edges of the subgraph are induced by the vertex set. That is,
325	every edge in the parent graph (which is <i>this</i> graph) that
326	connects two vertices in the subgraph will be added to the
327	subgraph.
328
329	<hr>
330	<pre>
331	vertex_descriptor local_to_global(vertex_descriptor u_local) const
332	</pre>
333	Converts a local vertex descriptor to the corresponding global
334	vertex descriptor.
335
336	<hr>
337	<pre>
338	vertex_descriptor global_to_local(vertex_descriptor u_global) const
339	</pre>
340	Converts a global vertex descriptor to the corresponding local
341	vertex descriptor.
342
343	<hr>
344	<pre>
345	edge_descriptor local_to_global(edge_descriptor e_local) const
346	</pre>
347	Converts a local edge descriptor to the corresponding global edge
348	descriptor.
349
350	<hr>
351	<pre>
352	edge_descriptor global_to_local(edge_descriptor u_global) const
353	</pre>
354	Converts a global edge descriptor to the corresponding local edge
355	descriptor.
356
357	<hr>
358	<pre>
359	std::pair<vertex_descriptor, bool> find_vertex(vertex_descriptor u_global) const
360	</pre>
361	If vertex <i>u</i> is in this subgraph, the function returns the local
362	vertex descriptor that corresponds to the global vertex descriptor
363	<tt>u_global</tt> as the first part of the pair and <tt>true</tt> for
364	the second part of the pair. If vertex <i>u</i> is not in the subgraph
365	then this function returns false in the second part of the
366	pair.
367
368	<hr>
369	<pre>
370	subgraph& root()
371	</pre>
372	Returns the root graph of the subgraph tree.
373
374	<hr>
375	<pre>
376	bool is_root() const
377	</pre>
378	Return <tt>true</tt> if the graph is the root of the subgraph tree,
379	and returns <tt>false</tt> otherwise.
380
381	<hr>
382	<pre>
383	subgraph& parent()
384	</pre>
385	Returns the parent graph.
386
387	<hr>
388	<pre>
389	std::pair<children_iterator, children_iterator> children() const
390	</pre>
391	Return an iterator pair for accessing the children subgraphs.
392
393
394	<!----------------------------->
395	<h3>Nonmember Functions</h3>
396
397	The functionality of <tt>subgraph</tt> depends on the
398	<tt>Graph</tt> type. For example, if <tt>Graph</tt> in a
399	<a href="BidirectionalGraph.html">BidirectionalGraph</a> and supports <tt>in_edges</tt>, then so
400	does <tt>subgraph</tt>. Here we list all the functions that
401	<tt>subgraph</tt> could possibly support given a <tt>Graph</tt>
402	type that is a model of <a href="VertexListGraph.html">VertexListGraph</a>, <a href="EdgeListGraph.html">EdgeListGraph</a> and
403	<a href="BidirectionalGraph.html">BidirectionalGraph</a>. If the <tt>Graph</tt> type that you use
404	with <tt>subgraph</tt> does not model these concepts and supports
405	fewer functions, then the <tt>subgraph</tt> will also support
406	fewer functions and some of the functions listed below will not be
407	implemented.
408
409
410	<hr>
411	<pre>
412	std::pair<vertex_iterator, vertex_iterator>
413	vertices(const subgraph& g)
414	</pre>
415	Returns an iterator range providing access to the vertex set of subgraph <i>g</i>.
416	(Required by <a href="VertexListGraph.html">VertexListGraph</a>.)
417
418	<hr>
419	<pre>
420	std::pair<edge_iterator, edge_iterator>
421	edges(const subgraph& g)
422	</pre>
423	Returns an iterator range providing access to the edge set of subgraph <i>g</i>.
424	(Required by <a href="EdgeListGraph.html">EdgeListGraph</a>.)
425
426	<hr>
427	<pre>
428	std::pair<adjacency_iterator, adjacency_iterator>
429	adjacent_vertices(vertex_descriptor u_local, const subgraph& g)
430	</pre>
431	Returns an iterator range providing access to the vertices
432	adjacent to
433	vertex <i>u</i> in subgraph <i>g</i>.
434	(Required by <a href="AdjacencyGraph.html">AdjacencyGraph</a>.)
435
436	<hr>
437	<pre>
438	std::pair<out_edge_iterator, out_edge_iterator>
439	out_edges(vertex_descriptor u_local, const subgraph& g)
440	</pre>
441	Returns an iterator range providing access to the out-edges of
442	vertex <i>u</i> in subgraph <i>g</i>. If the graph is undirected, this
443	iterator range provides access to all edge incident on
444	vertex <i>u</i>.
445	(Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
446
447	<hr>
448	<pre>
449	std::pair<in_edge_iterator, in_edge_iterator>
450	in_edges(vertex_descriptor v_local, const subgraph& g)
451	</pre>
452	Returns an iterator range providing access to the in-edges of
453	vertex
454	<i>v</i> in subgraph <i>g</i>.
455	(Required by <a href="BidirectionalGraph.html">BidirectionalGraph</a>.)
456
457	<hr>
458	<pre>
459	vertex_descriptor
460	source(edge_descriptor e_local, const subgraph& g)
461	</pre>
462	Returns the source vertex of edge <i>e</i> in subgraph <i>g</i>.
463	(Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
464
465	<hr>
466	<pre>
467	vertex_descriptor
468	target(edge_descriptor e_local, const subgraph& g)
469	</pre>
470	Returns the target vertex of edge <i>e</i> in subgraph <i>g</i>.
471	(Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
472
473	<hr>
474	<pre>
475	degree_size_type
476	out_degree(vertex_descriptor u_local, const subgraph& g)
477	</pre>
478	Returns the number of edges leaving vertex <i>u</i> in subgraph <i>g</i>.
479	(Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
480
481	<hr>
482	<pre>
483	degree_size_type in_degree(vertex_descriptor u_local, const subgraph& g)
484	</pre>
485	Returns the number of edges entering vertex <i>u</i> in subgraph <i>g</i>.
486	(Required by <a href="BidirectionalGraph.html">BidirectionalGraph</a>.)
487
488	<hr>
489	<pre>
490	vertices_size_type num_vertices(const subgraph& g)
491	</pre>
492	Returns the number of vertices in the subgraph <i>g</i>.
493	(Required by <a href="VertexListGraph.html">VertexListGraph</a>.)
494
495	<hr>
496	<pre>
497	edges_size_type num_edges(const subgraph& g)
498	</pre>
499	Returns the number of edges in the subgraph <i>g</i>. (Required by
500	<a href="EdgeListGraph.html">EdgeListGraph</a>.)
501
502	<hr>
503	<pre>
504	vertex_descriptor vertex(vertices_size_type n, const subgraph& g)
505	</pre>
506	Returns the <i>n</i>th vertex in the subgraph's vertex list.
507
508	<hr>
509	<pre>
510	std::pair<edge_descriptor, bool>
511	edge(vertex_descriptor u_local, vertex_descriptor v_local, const subgraph& g)
512	</pre>
513	Returns the edge connecting vertex <i>u</i> to vertex <i>v</i> in subgraph <i>g</i>.
514	(Required by <a href="AdjacencyMatrix.html">AdjacencyMatrix</a>.)
515
516
517
518	<hr>
519	<pre>
520	std::pair<edge_descriptor, bool>
521	add_edge(vertex_descriptor u_local, vertex_descriptor v_local, subgraph& g)
522	</pre>
523	Adds edge <i>(u,v)</i> to the subgraph <i>g</i> and to all of the subgraph's
524	ancestors in the subgraph tree. This function returns the edge
525	descriptor for the new edge. If the edge is already in the graph
526	then a duplicate will not be added and the Boolean flag will be
527	false.
528	(Required by <a href="EdgeMutableGraph.html">EdgeMutableGraph</a>.)
529
530	<hr>
531	<pre>
532	std::pair<edge_descriptor, bool>
533	add_edge(vertex_descriptor u_local, vertex_descriptor v_local,
534	const EdgeProperty& p, subgraph& g)
535	</pre>
536	Adds edge <i>(u,v)</i> to the graph and attaches <tt>p</tt> as the value
537	of the edge's internal property storage. Also see the previous
538	<tt>add_edge</tt> member function for more details.
539
540	<hr>
541	<pre>
542	void remove_edge(vertex_descriptor u_local, vertex_descriptor v_local,
543	subgraph& g)
544	</pre>
545	Removes the edge <i>(u,v)</i> from the subgraph and from all of the
546	ancestors of <tt>g</tt> in the subgraph tree.
547	(Required by <a href="EdgeMutableGraph.html">EdgeMutableGraph</a>.)
548
549	<hr>
550	<pre>
551	void remove_edge(edge_descriptor e_local, subgraph& g)
552	</pre>
553	Removes the edge <tt>e</tt> from the subgraph and from all of the
554	ancestors of <tt>g</tt> in the subgraph tree.
555	(Required by <a href="EdgeMutableGraph.html">EdgeMutableGraph</a>.)
556
557	<hr>
558	<pre>
559	vertex_descriptor
560	add_vertex(subgraph& g)
561	</pre>
562	Adds a vertex to the subgraph and returns the vertex descriptor
563	for the new vertex. The vertex is also added to all ancestors of
564	<tt>g</tt> in the subgraph tree to maintain the subgraph property.
565	(Required by <a href="VertexMutableGraph.html">VertexMutableGraph</a>.)
566
567	<hr>
568	<pre>
569	vertex_descriptor
570	add_vertex(vertex_descriptor u_global, subgraph& g)
571	</pre>
572	Adds the vertex <i>u</i> from the root graph to the subgraph <tt>g</tt>.
573	(Required by <a href="VertexMutableGraph.html">VertexMutableGraph</a>.)
574
575
576	<hr>
577	<pre>
578	template <class PropertyTag>
579	property_map<subgraph, PropertyTag>::type
580	get(PropertyTag, subgraph& g)
581
582	template <class PropertyTag>
583	property_map<subgraph, PropertyTag>::const_type
584	get(PropertyTag, const subgraph& g)
585	</pre>
586	Returns the property map object for the vertex or edge property
587	specified by <tt>PropertyTag</tt>. The <tt>PropertyTag</tt> must match one
588	of the properties specified in the graph's <tt>PropertyTag</tt>
589	template argument. Vertex and edge properties are shared by all
590	subgraphs, so changes to a property through a local vertex
591	descriptor for one subgraph will change the property for the
592	global vertex descriptor, and therefore for all other subgraphs.
593	However, the key type for a subgraph's property map is a subgraph-local
594	vertex or edge descriptor.
595	(Required by <a href="PropertyGraph.html">PropertyGraph</a>.)
596
597	<hr>
598	<pre>
599	template <class PropertyTag, class Key>
600	typename property_traits<
601	typename property_map<subgraph, PropertyTag>::const_type
602	>::value_type
603	get(PropertyTag, const subgraph& g, Key k_local)
604	</pre>
605	This returns the property value for the key <tt>k_local</tt>, which
606	is either a local vertex or local edge descriptor. See the above
607	<tt>get</tt> function
608	for more information about the propert maps.
609	(Required by <a href="PropertyGraph.html">PropertyGraph</a>.)
610
611	<hr>
612	<pre>
613	template <class PropertyTag, class Key, class Value>
614	void
615	put(PropertyTag, const subgraph& g, Key k_local, const Value& value)
616	</pre>
617	This sets the property value for the key <tt>k_local</tt> to
618	<tt>value</tt>. <tt>k_local</tt> is either a local vertex or local
619	edge descriptor. <tt>Value</tt> must be convertible to
620	<tt>typename
621	property_traits<property_map<adjacency_matrix,
622	PropertyTag>::type>::value_type</tt>.
623	(Required by <a href="PropertyGraph.html">PropertyGraph</a>.)
624
625	<hr>
626	<pre>
627	template <class GraphProperties, class GraphPropertyTag>
628	typename property_value<GraphProperties, GraphPropertyTag>::type&
629	get_property(subgraph& g, GraphPropertyTag);
630	</pre>
631	Return the property specified by <tt>GraphPropertyTag</tt> that is attached
632	to the subgraph object <tt>g</tt>. The <tt>property_value</tt> traits class
633	is defined in <tt>boost/pending/property.hpp</tt>.
634
635
636	<hr>
637	<pre>
638	template <class GraphProperties, class GraphPropertyTag>
639	const typename property_value<GraphProperties, GraphPropertyTag>::type&
640	get_property(const subgraph& g, GraphPropertyTag);
641	</pre>
642	Return the property specified by <tt>GraphPropertyTag</tt> that is
643	attached to the subgraph object <tt>g</tt>. The <tt>property_value</tt>
644	traits class is defined in <tt>boost/pending/property.hpp</tt>.
645
646	<hr>

Note: See TracBrowser for help on using the repository browser.

Download in other formats: