
BoostCommit : 
From: asutton_at_[hidden]
Date: 20070815 08:40:06
Author: asutton
Date: 20070815 08:40:06 EDT (Wed, 15 Aug 2007)
New Revision: 38675
URL: http://svn.boost.org/trac/boost/changeset/38675
Log:
Removing property map/matrix concepts
Removed:
sandbox/SOC/2007/graphs/libs/graph/doc/concepts/property_map.qbk
sandbox/SOC/2007/graphs/libs/graph/doc/concepts/property_matrix.qbk
Text files modified:
sandbox/SOC/2007/graphs/libs/graph/doc/concepts/utility.qbk  2 
1 files changed, 0 insertions(+), 2 deletions()
Deleted: sandbox/SOC/2007/graphs/libs/graph/doc/concepts/property_map.qbk
==============================================================================
 sandbox/SOC/2007/graphs/libs/graph/doc/concepts/property_map.qbk 20070815 08:40:06 EDT (Wed, 15 Aug 2007)
+++ (empty file)
@@ 1,106 +0,0 @@
[/
 / Copyright (c) 2007 Andrew Sutton
 /
 / Distributed under the Boost Software License, Version 1.0. (See accompanying
 / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 /]

[section Property Map]
The [BoostPropertyMap] concept is a refinement of the concepts in the Boost.PropertyMap
library this concept requires that property maps modeling this concept are required
to be constructed with a graph object.

[heading Refinement Of]
[BoostReadWritePropertyMap]

[heading Notation]
The following expressions are used within this document:
[table
 [[Expression] [Description]]
 [[M] [A type modeling the [BoostPropertyMap] concept.]]
 [[m] [An object of type `M`.]]
 [[c] [An object whose type models the [SgiRandomAccessContainer] concept.]]
 [[k] [An object of the property map's `key_type`.]]
 [[x] [An object of the property map's `value_type`.]]
]

[heading Expressions]
[table
 [[Name] [Expression] [Result Type] [Description]]
 [
 [Default Constructor]
 [
 `M m`

 `M()`
 ]
 []
 [
 Construct a property map `m` with no underlying container.
 This constructor is mainly used to convey type information to
 generic functions since it cannot function without the container.

 *Postconditions:* `m[k]`, `get(m, k)`, and `put(m, k, x)` have
 undefined behavior (i.e., are likely to crash the program).
 ]
 ]
 [
 [Property Graph Constructor]
 [
 `M m(c, g);`

 `M(c, g)`
 ]
 []
 [
 Construct a property map `m` over the container `c` with reference
 to the graph `g`.

 *Requirements*: The container type of `c` must be a model of the
 [SgiRandomAccessContainer] concept.

 *Postconditions:* if `k` is a valid vertex or edge descriptor of `g`
 then `m[k]`, `get(m, k)`, and `put(m, k, x)` are all valid operations,
 that either return or set the value `x` associated with the key `k`.

 *Complexity:* The property map is constructed in constant time.
 ]
 ]
]

[heading Notes]
This concept exists primarily to help enforce best practice for declaring and
using exterior properties. Note that none of the property maps implemented
in the Boost.PropertyMap library satisfy the requirements of this concept.
The only type that does satisfy these requirements is the `map_type` of the
[boost_exterior_property] template.

This concept is generally not used to impose requirements on property maps
passed to generic graph algorithms.

Also note that because the container `c` over which the property map is constructed
must be a model of the [SgiRandomAccessContainer] type. This is a fairly stringent
requirement, but if satisfied (e.g., via a `std::vector`) implies the property
map implements constanttime property access.

[heading Example]

 typedef undirected_graph<> Graph;
 typedef graph_traits<Graph>::vertex_descriptor Vertex;

 Graph g;
 // add vertices and edges

 typedef exterior_property<Graph, Vertex, std::size_t> DistanceProperty;
 typedef DistanceProperty::container_type DistanceContainer;
 typedef DistanceProperty::map_type DistanceMap;

 DistanceContainer distances(num_verticse(g), 0);
 DistanceMap dm(distances, g);

 Vertex v = *vertices(g).first;
 put(dm, v, 3); // set v's distance to 3
 get(dm, v); // returns 3
 dm[v]; // same as above, returns 3

[endsect]
Deleted: sandbox/SOC/2007/graphs/libs/graph/doc/concepts/property_matrix.qbk
==============================================================================
 sandbox/SOC/2007/graphs/libs/graph/doc/concepts/property_matrix.qbk 20070815 08:40:06 EDT (Wed, 15 Aug 2007)
+++ (empty file)
@@ 1,156 +0,0 @@
[/
 / Copyright (c) 2007 Andrew Sutton
 /
 / Distributed under the Boost Software License, Version 1.0. (See accompanying
 / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 /]

[section Property Matrix]
The [BoostPropertyMatrix] concept requires types that model it to allow
twodimensional array access to its values using descriptors. Types that model
this concepts are typically nested containers that use the vertex or edge
desctipors of a graph to access the elements of the matrix.

Note that the term "matrix" can be misleading since types that model this
concept are not necessarily required to have a "square" memory structure. The
term "matrix" applies to the use of doubleindexing to access its elements
(i.e., m[u][v]).

Despite the relative simplicity of this concept, it should be noted that
types such as nested vectors cannot implicitly model this concept due to the
additional type requirements of the `property_matrix_types` template. Hoever,
that template can be specialized such that the requirements are met. In general,
however, it is far easier to use the `matrix_type` of the [boost_exterior_property]
template to declare types that model his concept.

[heading Notation]
The following expressions are used within this document:
[table
 [[Expression] [Description]]
 [[M] [A type modeling the [BoostPropertyMatrix] concept.]]
 [[m] [An object of type `M`.]]
 [[n] [An unsigned integer.]]
 [[g] [An object whose type is a model of the [BoostGraph] concept.]]
]

[heading Associated Types]
[table
 [[Name] [Type] [Description]]
 [
 [Key Type]
 [`property_matrix_traits<M>::key_type`]
 [
 The type of key used to index values in the matrix.

 *Requirements:* The `key_type` must be a model of a [BoostDescriptor]
 and be the same type as either the `vertex_descriptor` or `edge_descriptor`
 of the graph for which the matrix is declared.
 ]
 ]
 [
 [Value Type]
 [`property_matrix_traits<M>::value_type`]
 [
 The type of values contained by the matrix.

 *Requirements:* The `value_type` must be default construtible.
 ]
 ]
 [
 [Container Type]
 [`property_matrix_traits<M>::container_type`]
 [
 The nested container that stores the values of each column in the
 matrix.

 *Requirements:* The `container_type` is a [SgiContainer] such that
 the `value_type` of the container is the same as the `value_type`
 of the matrix. The container must be [NoConcept Idexable] with the
 index type being the same as the `key_type` of the matrix.
 ]
 ]
 [
 [Map Type]
 [`property_matrix_traits<M>::map_type`]
 [
 The type of property map that can be constructed over the `container_type`
 of the matrix.

 *Requirements:* The `container_type` is a [SgiContainer] such that
 the `value_type` of the container is the same as the `value_type`
 of the matrix. The container must be [NoConcept Idexable] with the
 index type being the same as the `key_type` of the matrix.
 ]
 ]
 [
 [Matrix Type]
 [`property_matrix_traits<M>::matrix_type`]
 [
 The type of the underlying matrix. This may not be the same type
 as `M`.
 ]
 ]
]

[heading Expressions]
[table
 [[Name] [Expression] [Result Type] [Description]]
 [
 [Fill Constructor]
 [
 `M m(n, g)`

 `M(n, g)`
 ]
 []
 [
 Contstruct the matrix with `nxn` elements. After construction,
 accessing elements with the range defined by the square matrix
 is guaranteed to succeed.

 *Preconditions:* `n >= num_vertices(g)`.

 *Postcondition:* If `i` and `j` are valid vertex or edge descriptors
 of `g`, then `m[i][j]` returns the value associated with the descriptor
 pair.
 ]
 ]
 [
 [Element Access]
 [`m[u][v]`]
 [
 `property_matrix_traits<M>::value_type&`

 `const property_matrix_traits<M>::value_type&`
 ]
 [
 Returns the element corresponding to the pair `u`, `v` in the
 matrix.

 *Requirements:* The keys `u` and `v` must be the same as the `key_type`
 for the matrix.

 *Preconditions:* The keys `u` and `v` must be valid vertex or edge
 descriptors of the graph to which the matrix applies.
 ]
 ]
 [
 [Row Access]
 [`m[u]`]
 [
 An [StdIndexable] type.
 ]
 [
 Returns the row associated with the key `u`.

 *Requirements:* The key `u` must be the same as the `key_type`
 for the matrix. The return type is guaranteed to be indexable with
 the key type `k`.

 *Preconditions:* The key `u` must be valid vertex or edge descriptor
 of the graph to which the matrix applies.
 ]
 ]
]

[endsect]
Modified: sandbox/SOC/2007/graphs/libs/graph/doc/concepts/utility.qbk
==============================================================================
 sandbox/SOC/2007/graphs/libs/graph/doc/concepts/utility.qbk (original)
+++ sandbox/SOC/2007/graphs/libs/graph/doc/concepts/utility.qbk 20070815 08:40:06 EDT (Wed, 15 Aug 2007)
@@ 11,8 +11,6 @@
[include descriptor.qbk]
[include numeric_value.qbk]
[include property_map.qbk]
[include property_matrix.qbk]
[include degree_measure.qbk]
[include distance_measure.qbk]
BoostCommit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk