Now an explicit conversion to a compatible python type is attempted if
the value being set in a property map cannot be converted directly to a
C++ type.

This also fixes a bug with vector-valued property maps.

The arrays returned by PropertyMap.get_array() are now PropertyArray
instances, which keep track of the PropertyMap data, and are able to
detect when it changes, and raise a ValueError exception. As such, it
becomes impossible to read or write to non-allocated memory if an array
becomes invalid.

These functions/properties provide more information and control about
edge indexing, which might be useful.

The reserved size for the array was set to g.num_edges(), but it should
be set to the maximum edge index + 1, since some edges might have been
deleted.

Now vector types of property maps can be accessed as arrays with the
get_array() and 'a' property, just like scalar property maps.

This fixes a small typo bug, which prevented loading from file-like
objects.

It is now possible to obtain the vertex with index i even for filtered graphs.

Since the same edge appears twice in Vertex.all_edges() if it is a
self_loop, it would be deleted twice in Graph.clear_vertex(), raising an
exception. Now, the edges are stored in a set first, avoiding this
problem.

This completes all the documentation up to this point.

This fixes an obvious problem, where the graph gets deleted, and the
descriptors are still lying around. Usage of orphaned descriptors will
now just raise a ValueError.

The __repr__ function of Edge, Vertex, and PropertyMap now give
something more informative about each object.

This provides convienent access to the underlying array values, such as:

   p.a = random(len(p.a))

instead of:

   p.get_array()[:] = random(len(p.get_array()))

(the latter is still supported)

These functions group several scalar properties into one vector
properties, and ungroup a vector property into several scalar
properties.

This also includes convenience property map checks.

No longer only thrown GraphError upon any error, but instead throw
specific exceptions which are more meaninful and are mapped to standard
python exceptions, such as IOError, ValueError and RuntimeError.

This would cause the graph to become directed (when previously
undirected) in some circumstances.

This prints useful library information.

This modified several docstrings and introduces a quick-start guide.

Now the parameter "all" is ignored, if any of the other parameters is
True.

The following is now possible:

    g = Graph(directed=False)

Instead of the only way previously:

   g = Graph()
   g.set_directed(False)

The following conversions are now possible: int(v) and tuple(e), where v
and e are Vertex and Edge instances, respectively.

Now all filters are stashed by default. In order to override this, the
parameter all=False needs to be passed, and the individual filters need
to be specified.

Individual filters can be stashed and popped by passing keyword
arguments to the respective functions. Additionally the filter state can
be obtained and set directly, with the get_filter_state() and
set_filter_state() functions.