Remove Boost::geometry from CMakeLists

Remove old platforms

.clang-format

@@ -5,6 +5,7 @@ AlignEscapedNewlinesLeft: true
 AlwaysBreakAfterDefinitionReturnType: None
 BreakBeforeBraces: Allman
 BreakConstructorInitializersBeforeComma: false
+BreakTemplateDeclarations: Yes
 ColumnLimit: 80
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 0

.drone.star

@@ -14,149 +14,35 @@ windowsglobalimage="cppalliance/dronevs2019"
 
 def main(ctx):
   return [
-  linux_cxx("g++-4.4 98", "g++", packages="g++-4.4", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.4', 'CXXSTD': '98', }, globalenv=globalenv),
-  linux_cxx("g++-4.4 0x", "g++", packages="g++-4.4", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.4', 'CXXSTD': '0x', }, globalenv=globalenv),
-  linux_cxx("g++-4.6 03", "g++", packages="g++-4.6", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.6', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("g++-4.6 0x", "g++", packages="g++-4.6", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.6', 'CXXSTD': '0x', }, globalenv=globalenv),
-  linux_cxx("g++-4.7 03", "g++-4.7", packages="g++-4.7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.7', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("g++-4.7 11", "g++-4.7", packages="g++-4.7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.7', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("g++-4.8 03", "g++-4.8", packages="g++-4.8", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.8', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("g++-4.8 11", "g++-4.8", packages="g++-4.8", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.8', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("g++-4.9 03", "g++-4.9", packages="g++-4.9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.9', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("g++-4.9 11", "g++-4.9", packages="g++-4.9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.9', 'CXXSTD': '11', }, globalenv=globalenv),
-  
-  linux_cxx("g++-5 03", "g++-5", packages="g++-5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("g++-5 11", "g++-5", packages="g++-5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("g++-5 14", "g++-5", packages="g++-5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("g++-5 1z", "g++-5", packages="g++-5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '1z', }, globalenv=globalenv),
-  
-  linux_cxx("g++-6 03", "g++-6", packages="g++-6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("g++-6 11", "g++-6", packages="g++-6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("g++-6 14", "g++-6", packages="g++-6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("g++-6 1z", "g++-6", packages="g++-6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("g++-7 03", "g++-7", packages="g++-7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("g++-7 11", "g++-7", packages="g++-7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '11', }, globalenv=globalenv),
   linux_cxx("g++-7 14", "g++-7", packages="g++-7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '14', }, globalenv=globalenv),
   linux_cxx("g++-7 17", "g++-7", packages="g++-7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '17', }, globalenv=globalenv),
 
-  linux_cxx("g++-8 03", "g++-8", packages="g++-8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("g++-8 11", "g++-8", packages="g++-8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '11', }, globalenv=globalenv),
   linux_cxx("g++-8 14", "g++-8", packages="g++-8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '14', }, globalenv=globalenv),
   linux_cxx("g++-8 17", "g++-8", packages="g++-8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '17', }, globalenv=globalenv),
 
-  linux_cxx("g++-9 03", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("g++-9 11", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '11', }, globalenv=globalenv),
   linux_cxx("g++-9 14", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '14', }, globalenv=globalenv),
   linux_cxx("g++-9 17", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '17', }, globalenv=globalenv),
   linux_cxx("g++-9 2a", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '2a', }, globalenv=globalenv),
 
-  linux_cxx("g++-10 11", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '11', }, globalenv=globalenv),
   linux_cxx("g++-10 14", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '14', }, globalenv=globalenv),
   linux_cxx("g++-10 17", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '17', }, globalenv=globalenv),
   linux_cxx("g++-10 20", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '20', }, globalenv=globalenv),
-
-  linux_cxx("clang++-3.5 03", "clang++", packages="clang-3.5", llvm_os="precise", llvm_ver="3.5", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.5', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-3.5 11", "clang++", packages="clang-3.5", llvm_os="precise", llvm_ver="3.5", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.5', 'CXXSTD': '11', }, globalenv=globalenv),
-  #linux_cxx("clang++-3.5 14", "clang++", packages="clang-3.5", llvm_os="precise", llvm_ver="3.5", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.5', 'CXXSTD': '14', }, globalenv=globalenv),
-  #linux_cxx("clang++-3.5 1z", "clang++", packages="clang-3.5", llvm_os="precise", llvm_ver="3.5", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.5', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-3.6 03", "clang++", packages="clang-3.6", llvm_os="precise", llvm_ver="3.6", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.6', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-3.6 11", "clang++", packages="clang-3.6", llvm_os="precise", llvm_ver="3.6", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.6', 'CXXSTD': '11', }, globalenv=globalenv),
-  #linux_cxx("clang++-3.6 14", "clang++", packages="clang-3.6", llvm_os="precise", llvm_ver="3.6", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.6', 'CXXSTD': '14', }, globalenv=globalenv),
-  #linux_cxx("clang++-3.6 1z", "clang++", packages="clang-3.6", llvm_os="precise", llvm_ver="3.6", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.6', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-3.7 03", "clang++", packages="clang-3.7", llvm_os="precise", llvm_ver="3.7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.7', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-3.7 11", "clang++", packages="clang-3.7", llvm_os="precise", llvm_ver="3.7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.7', 'CXXSTD': '11', }, globalenv=globalenv),
-  #linux_cxx("clang++-3.7 14", "clang++", packages="clang-3.7", llvm_os="precise", llvm_ver="3.7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.7', 'CXXSTD': '14', }, globalenv=globalenv),
-  #linux_cxx("clang++-3.7 1z", "clang++", packages="clang-3.7", llvm_os="precise", llvm_ver="3.7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.7', 'CXXSTD': '1z', }, globalenv=globalenv),
   
-  linux_cxx("clang++-3.8 03", "clang++-3.8", packages="clang-3.8", llvm_os="precise", llvm_ver="3.8", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-3.8 11", "clang++-3.8", packages="clang-3.8", llvm_os="precise", llvm_ver="3.8", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'CXXSTD': '11', }, globalenv=globalenv),
-  # These have issues not of our making:
-  #linux_cxx("clang++-3.8 14", "clang++-3.8", packages="clang-3.8", llvm_os="precise", llvm_ver="3.8", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'CXXSTD': '14', }, globalenv=globalenv),
-  #linux_cxx("clang++-3.8 1z", "clang++-3.8", packages="clang-3.8", llvm_os="precise", llvm_ver="3.8", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-3.9 03", "clang++-3.9", packages="clang-3.9", llvm_os="precise", llvm_ver="3.9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.9', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-3.9 11", "clang++-3.9", packages="clang-3.9", llvm_os="precise", llvm_ver="3.9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.9', 'CXXSTD': '11', }, globalenv=globalenv),
-  # These have issues not of our making:
-  #linux_cxx("clang++-3.9 14", "clang++-3.9", packages="clang-3.9", llvm_os="precise", llvm_ver="3.9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.9', 'CXXSTD': '14', }, globalenv=globalenv),
-  #linux_cxx("clang++-3.9 1z", "clang++-3.9", packages="clang-3.9", llvm_os="precise", llvm_ver="3.9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.9', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-4.0 03", "clang++-4.0", packages="clang-4.0", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-4.0 11", "clang++-4.0", packages="clang-4.0", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("clang++-4.0 14", "clang++-4.0", packages="clang-4.0", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("clang++-4.0 1z", "clang++-4.0", packages="clang-4.0", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-5.0 03", "clang++-5.0", packages="clang-5.0", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-5.0 11", "clang++-5.0", packages="clang-5.0", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("clang++-5.0 14", "clang++-5.0", packages="clang-5.0", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("clang++-5.0 1z", "clang++-5.0", packages="clang-5.0", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-6.0 03", "clang++-6.0", packages="clang-6.0", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-6.0 11", "clang++-6.0", packages="clang-6.0", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("clang++-6.0 14", "clang++-6.0", packages="clang-6.0", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("clang++-6.0 1z", "clang++-6.0", packages="clang-6.0", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-7 03", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-7 14", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("clang++-7 17", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("clang++-7 1z", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-8 03", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-8 11", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '11', }, globalenv=globalenv),
+  linux_cxx("clang++-7 14", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '14', }, globalenv=globalenv),
+  linux_cxx("clang++-7 17", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '17', }, globalenv=globalenv),
+  
   linux_cxx("clang++-8 14", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '14', }, globalenv=globalenv),
   linux_cxx("clang++-8 17", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '17', }, globalenv=globalenv),
-  linux_cxx("clang++-8 2a", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '2a', }, globalenv=globalenv),
 
-  linux_cxx("clang++-9 03", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-9 11", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '11', }, globalenv=globalenv),
   linux_cxx("clang++-9 14", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '14', }, globalenv=globalenv),
   linux_cxx("clang++-9 17", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '17', }, globalenv=globalenv),
-  linux_cxx("clang++-9 2a", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '2a', }, globalenv=globalenv),
 
-  linux_cxx("clang++-10 03", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '03', }, globalenv=globalenv),
-  linux_cxx("clang++-10 11", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '11', }, globalenv=globalenv),
   linux_cxx("clang++-10 14", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '14', }, globalenv=globalenv),
   linux_cxx("clang++-10 17", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '17', }, globalenv=globalenv),
   linux_cxx("clang++-10 20", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '20', }, globalenv=globalenv),
 
-  osx_cxx("XCode-11.7 03", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03', }, globalenv=globalenv),
-  osx_cxx("XCode-11.7 11", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11', }, globalenv=globalenv),
   osx_cxx("XCode-11.7 14", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '14', }, globalenv=globalenv),
   osx_cxx("XCode-11.7 17", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '17', }, globalenv=globalenv),
-  osx_cxx("XCode-11.7 2a", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '2a', }, globalenv=globalenv),
-
-#   We don't support these old versions of Xcode any more, but you are welcome to take up the challenge for doing so if you need them.
-    
-#   osx_cxx("XCode-10.2 03", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03', }, globalenv=globalenv),
-#   osx_cxx("XCode-10.2 11", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11', }, globalenv=globalenv),
-#   osx_cxx("XCode-10.2 14", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '14', }, globalenv=globalenv),
-#   osx_cxx("XCode-10.2 17", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '17', }, globalenv=globalenv),
-#   osx_cxx("XCode-10.2 2a", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '2a', }, globalenv=globalenv),
-
-#   osx_cxx("XCode-9.4 03", "clang++", packages="", buildtype="boost", xcode_version="9.4", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03', }, globalenv=globalenv),
-#   osx_cxx("XCode-9.4 11", "clang++", packages="", buildtype="boost", xcode_version="9.4", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11', }, globalenv=globalenv),
-#   osx_cxx("XCode-9.4 14", "clang++", packages="", buildtype="boost", xcode_version="9.4", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '14', }, globalenv=globalenv),
-#   osx_cxx("XCode-9.4 1z", "clang++", packages="", buildtype="boost", xcode_version="9.4", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-#   osx_cxx("XCode-9.0 03", "clang++", packages="", buildtype="boost", xcode_version="9", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03', }, globalenv=globalenv),
-#   osx_cxx("XCode-9.0 11", "clang++", packages="", buildtype="boost", xcode_version="9", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11', }, globalenv=globalenv),
-#   osx_cxx("XCode-9.0 14", "clang++", packages="", buildtype="boost", xcode_version="9", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '14', }, globalenv=globalenv),
-#   osx_cxx("XCode-9.0 1z", "clang++", packages="", buildtype="boost", xcode_version="9", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-#   osx_cxx("XCode-8.3 03", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03', }, globalenv=globalenv),
-#   osx_cxx("XCode-8.3 11", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11', }, globalenv=globalenv),
-#   osx_cxx("XCode-8.3 14", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '14', }, globalenv=globalenv),
-#   osx_cxx("XCode-8.3 1z", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-#   osx_cxx("XCode-8.0 03", "clang++", packages="", buildtype="boost", xcode_version="8", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03', }, globalenv=globalenv),
-#   osx_cxx("XCode-8.0 11", "clang++", packages="", buildtype="boost", xcode_version="8", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11', }, globalenv=globalenv),
-#   osx_cxx("XCode-8.0 14", "clang++", packages="", buildtype="boost", xcode_version="8", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '14', }, globalenv=globalenv),
-#   osx_cxx("XCode-8.0 1z", "clang++", packages="", buildtype="boost", xcode_version="8", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-#   osx_cxx("XCode-7.3 03", "clang++", packages="", buildtype="boost", xcode_version="7.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03', }, globalenv=globalenv),
-#   osx_cxx("XCode-7.3 11", "clang++", packages="", buildtype="boost", xcode_version="7.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11', }, globalenv=globalenv),
   ]
 
 # from https://github.com/boostorg/boost-ci

.github/workflows/ci.yml

@@ -7,16 +7,15 @@
 name: CI
 on: [ push, pull_request ]
 jobs:
-  ubuntu-focal:
-    runs-on: ubuntu-20.04
+  ubuntu:
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
-      # Removed g++-10 because of an ICE; meant to be fixed in 10.2?
-      # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94938
-        compiler: [ g++-9, clang++-10 ]
+        compiler: [ gcc-14, clang-19 ]
+        cxxstd: [ 14, 17, 20, 23 ]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@master
         with:
           fetch-depth: '0'
       - uses: mstachniuk/ci-skip@v1
@@ -24,12 +23,12 @@ jobs:
           commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[apple];[Apple];[APPLE]'
           commit-filter-separator: ';'
           fail-fast: true
-      - name: Set TOOLSET
-        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
-      - name: Add repository
-        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Set ENV
+        run: |
+          echo ${{ matrix.compiler }} | awk '/^gcc/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
+          echo ${{ matrix.compiler }} | awk '/^gcc/ { gsub(/gcc/,"CXX=g++"); print; } /^clang/ { gsub(/clang/,"CXX=clang++"); print; }' >> $GITHUB_ENV
       - name: Install packages
-        run: sudo apt install g++-9 clang-10
+        run: sudo apt install ${{ matrix.compiler }}
       - name: Checkout main boost
         run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
       - name: Update tools/boostdep
@@ -48,60 +47,13 @@ jobs:
         run: ./b2 headers
         working-directory: ../boost-root
       - name: Generate user config
-        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} ;" > ~/user-config.jam'
+        run: 'echo "using $TOOLSET : : $CXX ;" > ~/user-config.jam'
         working-directory: ../boost-root
       - name: Config info
-        run: ../../../b2 print_config_info toolset=$TOOLSET cxxstd=03,11,14,17,2a
+        run: ../../../b2 print_config_info toolset=$TOOLSET cxxstd=${{ matrix.cxxstd }}
         working-directory: ../boost-root/libs/config/test
       - name: Test
-        run: ../../../b2 toolset=$TOOLSET cxxstd=03,11,14,17,2a
-        working-directory: ../boost-root/libs/graph/test
-  ubuntu-bionic:
-    runs-on: ubuntu-18.04
-    strategy:
-      fail-fast: false
-      matrix:
-        compiler: [ g++-7, g++-8, clang++-7, clang++-8 ]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: '0'
-      - uses: mstachniuk/ci-skip@v1
-        with:
-          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[apple];[Apple];[APPLE]'
-          commit-filter-separator: ';'
-          fail-fast: true
-      - name: Set TOOLSET
-        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
-      - name: Add repository
-        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
-      - name: Install packages
-        run: sudo apt install g++-7 g++-8 clang-7 clang-8
-      - name: Checkout main boost
-        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
-      - name: Update tools/boostdep
-        run: git submodule update --init tools/boostdep
-        working-directory: ../boost-root
-      - name: Copy files
-        run: cp -r $GITHUB_WORKSPACE/* libs/graph
-        working-directory: ../boost-root
-      - name: Install deps
-        run: python tools/boostdep/depinst/depinst.py graph
-        working-directory: ../boost-root
-      - name: Bootstrap
-        run: ./bootstrap.sh
-        working-directory: ../boost-root
-      - name: Generate headers
-        run: ./b2 headers
-        working-directory: ../boost-root
-      - name: Generate user config
-        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} ;" > ~/user-config.jam'
-        working-directory: ../boost-root
-      - name: Config info install
-        run: ../../../b2 print_config_info toolset=$TOOLSET cxxstd=03,11,14,17
-        working-directory: ../boost-root/libs/config/test
-      - name: Test
-        run: ../../../b2 toolset=$TOOLSET cxxstd=03,11,14,17
+        run: ../../../b2 toolset=$TOOLSET cxxstd=${{ matrix.cxxstd }}
         working-directory: ../boost-root/libs/graph/test
   macos:
     runs-on: macos-latest
@@ -109,8 +61,9 @@ jobs:
       fail-fast: false
       matrix:
         toolset: [ clang ]
+        cxxstd: [ 14, 17, 20 ]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@master
         with:
           fetch-depth: '0'
       - uses: mstachniuk/ci-skip@v1
@@ -136,92 +89,10 @@ jobs:
         run: ./b2 headers
         working-directory: ../boost-root
       - name: Config info
-        run: ../../../b2 print_config_info toolset=${{ matrix.toolset }} cxxstd=03,11,14,17,2a
+        run: ../../../b2 print_config_info toolset=${{ matrix.toolset }} cxxstd=${{ matrix.cxxstd }}
         working-directory: ../boost-root/libs/config/test
       - name: Test
-        run: ../../../b2 toolset=${{ matrix.toolset }} cxxstd=03,11,14,17,2a define=CI_SUPPRESS_KNOWN_ISSUES
-        working-directory: ../boost-root/libs/graph/test
-  windows_msvc_14_0:
-    runs-on: windows-2019
-    defaults:
-      run:
-        shell: cmd
-    strategy:
-      fail-fast: false
-      matrix:
-        toolset: [ msvc-14.0 ]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: '0'
-      - uses: mstachniuk/ci-skip@v1
-        with:
-          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[apple];[Apple];[APPLE];[linux];[Linux];[LINUX]'
-          commit-filter-separator: ';'
-          fail-fast: true
-      - name: Checkout main boost
-        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
-      - name: Update tools/boostdep
-        run: git submodule update --init tools/boostdep
-        working-directory: ../boost-root
-      - name: Copy files
-        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\graph
-        working-directory: ../boost-root
-      - name: Install deps
-        run: python tools/boostdep/depinst/depinst.py graph
-        working-directory: ../boost-root
-      - name: Bootstrap
-        run: bootstrap
-        working-directory: ../boost-root
-      - name: Generate headers
-        run: b2 headers
-        working-directory: ../boost-root
-      - name: Config info
-        run: ..\..\..\b2 print_config_info cxxstd=14,17 address-model=64 toolset=msvc-14.0
-        working-directory: ../boost-root/libs/config/test
-      - name: Test
-        run: ..\..\..\b2 --hash address-model=64 cxxstd=14,17 toolset=msvc-14.0
-        working-directory: ../boost-root/libs/graph/test
-  windows_msvc_14_2:
-    runs-on: windows-2019
-    defaults:
-      run:
-        shell: cmd
-    strategy:
-      fail-fast: false
-      matrix:
-        toolset: [ msvc-14.2 ]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: '0'
-      - uses: mstachniuk/ci-skip@v1
-        with:
-          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[apple];[Apple];[APPLE];[linux];[Linux];[LINUX]'
-          commit-filter-separator: ';'
-          fail-fast: true
-      - name: Checkout main boost
-        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
-      - name: Update tools/boostdep
-        run: git submodule update --init tools/boostdep
-        working-directory: ../boost-root
-      - name: Copy files
-        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\graph
-        working-directory: ../boost-root
-      - name: Install deps
-        run: python tools/boostdep/depinst/depinst.py graph
-        working-directory: ../boost-root
-      - name: Bootstrap
-        run: bootstrap
-        working-directory: ../boost-root
-      - name: Generate headers
-        run: b2 headers
-        working-directory: ../boost-root
-      - name: Config info
-        run: ..\..\..\b2 print_config_info cxxstd=14,17,20 address-model=64 toolset=msvc-14.2
-        working-directory: ../boost-root/libs/config/test
-      - name: Test
-        run: ..\..\..\b2 --hash address-model=64 cxxstd=14,17,20 toolset=msvc-14.2
+        run: ../../../b2 toolset=${{ matrix.toolset }} cxxstd=${{ matrix.cxxstd }} define=CI_SUPPRESS_KNOWN_ISSUES
         working-directory: ../boost-root/libs/graph/test
   windows_msvc_14_3:
     runs-on: windows-2022
@@ -264,3 +135,223 @@ jobs:
       - name: Test
         run: ..\..\..\b2 --hash address-model=64 cxxstd=14,17,20 toolset=msvc-14.3
         working-directory: ../boost-root/libs/graph/test
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+          - os: ubuntu-24.04
+          - os: macos-14
+          - os: macos-15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+          - os: ubuntu-24.04
+          - os: macos-14
+          - os: macos-15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2022
+          - os: windows-2025
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2022
+          - os: windows-2025
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release

.gitignore

@@ -6,3 +6,7 @@ kevin-bacon2.dat
 random.dot
 triangular-fr.dot
 triangular-kk.dot
+test/*.dot
+example/routing-table.dat
+example/figs/ospf-sptree.dot
+CMakeFiles/

CMakeLists.txt

@@ -2,7 +2,7 @@
 # Distributed under the Boost Software License, Version 1.0.
 # https://www.boost.org/LICENSE_1_0.txt
 
-cmake_minimum_required(VERSION 3.5...3.16)
+cmake_minimum_required(VERSION 3.8...3.16)
 
 project(boost_graph VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
 
@@ -22,7 +22,6 @@ target_link_libraries(boost_graph
     Boost::array
     Boost::assert
     Boost::bimap
-    Boost::bind
     Boost::concept_check
     Boost::config
     Boost::container_hash

README.md

@@ -1,4 +1,4 @@
-Boost Graph Library  [![Build Status](https://drone.cpp.al/api/badges/boostorg/graph/status.svg)](https://drone.cpp.al/boostorg/graph)[![Build Status](https://github.com/boostorg/graph/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/graph/actions)
+# Boost Graph Library
 
 ===================
 
@@ -6,7 +6,7 @@ A generic interface for traversing graphs, using C++ templates.
 
 The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/graph/doc/index.html).
 
-## Support, bugs and feature requests ##
+## Support, bugs and feature requests
 
 Bugs and feature requests can be reported through the [Github issue page](https://github.com/boostorg/graph/issues).
 
@@ -22,13 +22,15 @@ You can submit your changes through a [pull request](https://github.com/boostorg
 There is no mailing-list specific to Boost Graph, although you can use the general-purpose Boost [mailing-list](http://lists.boost.org/mailman/listinfo.cgi/boost-users) using the tag [graph].
 
 
-## Development ##
+### Build Status
 
 |                  |  Master  |   Develop   |
 |------------------|----------|-------------|
-| Github Actions | [![Build Status](https://github.com/boostorg/graph/workflows/CI/badge.svg?branch=master)](https://github.com/boostorg/graph/actions) | [![Build Status](https://github.com/boostorg/graph/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/graph/actions) |
+| Github Actions | [![Build Status](https://github.com/boostorg/graph/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/graph/actions) | [![Build Status](https://github.com/boostorg/graph/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/graph/actions) |
 |Drone | [![Build Status](https://drone.cpp.al/api/badges/boostorg/graph/status.svg?ref=refs/heads/master)](https://drone.cpp.al/boostorg/graph) | [![Build Status](https://drone.cpp.al/api/badges/boostorg/graph/status.svg)](https:/drone.cpp.al/boostorg/graph) |
 
+## Development
+
 Clone the whole boost project, which includes the individual Boost projects as submodules ([see boost+git doc](https://github.com/boostorg/boost/wiki/Getting-Started)):
 
     git clone https://github.com/boostorg/boost
@@ -45,7 +47,7 @@ Boost Graph Library is mostly made of headers but also contains some compiled co
 
 **Note:** The Boost Graph Library cannot currently be built outside of Boost itself.
 
-### Running tests ###
+### Running tests
 First, make sure you are in `libs/graph/test`.
 You can either run all the 300+ tests listed in `Jamfile.v2` or run a single test:
 

build.jam

@@ -0,0 +1,62 @@
+# Copyright René Ferdinand Rivera Morell 2024
+# 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)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/algorithm//boost_algorithm
+    /boost/any//boost_any
+    /boost/array//boost_array
+    /boost/assert//boost_assert
+    /boost/bimap//boost_bimap
+    /boost/bind//boost_bind
+    /boost/concept_check//boost_concept_check
+    /boost/config//boost_config
+    /boost/container_hash//boost_container_hash
+    /boost/conversion//boost_conversion
+    /boost/core//boost_core
+    /boost/detail//boost_detail
+    /boost/foreach//boost_foreach
+    /boost/function//boost_function
+    /boost/geometry//boost_geometry
+    /boost/integer//boost_integer
+    /boost/iterator//boost_iterator
+    /boost/lexical_cast//boost_lexical_cast
+    /boost/math//boost_math_tr1
+    /boost/move//boost_move
+    /boost/mpl//boost_mpl
+    /boost/multi_index//boost_multi_index
+    /boost/optional//boost_optional
+    /boost/parameter//boost_parameter
+    /boost/preprocessor//boost_preprocessor
+    /boost/property_map//boost_property_map
+    /boost/property_tree//boost_property_tree
+    /boost/random//boost_random
+    /boost/range//boost_range
+    /boost/serialization//boost_serialization
+    /boost/smart_ptr//boost_smart_ptr
+    /boost/spirit//boost_spirit
+    /boost/static_assert//boost_static_assert
+    /boost/throw_exception//boost_throw_exception
+    /boost/tti//boost_tti
+    /boost/tuple//boost_tuple
+    /boost/type_traits//boost_type_traits
+    /boost/typeof//boost_typeof
+    /boost/unordered//boost_unordered
+    /boost/utility//boost_utility
+    /boost/xpressive//boost_xpressive ;
+
+project /boost/graph
+    ;
+
+explicit
+    [ alias boost_graph : build//boost_graph ]
+    [ alias all : boost_graph example test ]
+    ;
+
+call-if : boost-library graph
+    : install boost_graph
+    ;
+

build/Jamfile.v2

@@ -6,9 +6,15 @@
 
 import mpi ;
 
-project boost/graph
-    : requirements <include>../src
+constant boost_dependencies_private :
+    /boost/regex//boost_regex
+    ;
+
+project
+    : common-requirements <include>../include <library>$(boost_dependencies)
+    : requirements <include>../src <library>$(boost_dependencies_private)
     : source-location ../src
+    : usage-requirements <define>BOOST_GRAPH_NO_LIB=1
     ;
 
 lib boost_graph
@@ -16,7 +22,6 @@ lib boost_graph
     read_graphviz_new.cpp
     graphml.cpp
     :
-    <library>../../regex/build//boost_regex
     <link>shared:<define>BOOST_GRAPH_DYN_LINK=1
     # Without these flags, MSVC 7.1 and 8.0 crash
     # User reports that VC++ 8.0 does not fail anymore, so that is removed
@@ -25,5 +30,3 @@ lib boost_graph
     :
     :
     ;
-
-boost-install boost_graph ;

doc/bibliography.html

@@ -453,6 +453,11 @@ Journal of the ACM (JACM), 23(2): 221-234, 1976.
 <em>Data Structures for Weighted Matching and Nearest Common Ancestors with Linking</em><br>
 Proceedings of the First Annual ACM-SIAM Symposium on Discrete Algorithms, pp. 434-443, 1990.
 
+<p></p><dt><a name="galil86">77</a>
+<dd>Zvi Galil<br>
+<em><a href="https://dl.acm.org/doi/pdf/10.1145/6462.6502">Efficient Algorithms for Finding Maximum Matching in Graphs</a></em><br>
+ACM Computing Surveys (CSUR), 18(1), 23-38, 1986.
+
 </dl>
 
 <br>

doc/challenge.html

@@ -37,7 +37,7 @@ review. The pending items are:</li>
      <tt>mutable_queue.hpp</tt>, <tt>fibonacci_heap.hpp</tt>.
       Somehow merge implementation with Dietmer's heaps and queues.</li>
 
-   <li><tt>disjoint_sets</tt> (see <a href="disjoint_sets.html">)</li>
+   <li><tt>disjoint_sets</tt> (see <a href="disjoint_sets.html">Disjoint Sets</a>)</li>
   </ul>
 
 <li>Construct a set of planar graph algorithms.</li>

doc/disjoint_sets.html

@@ -169,7 +169,7 @@ disjoint_sets<Rank, Parent, FindCompress>
   very slowly, much more slowly than the <i>log</i> function.</p>
 
   <h3>See Also</h3><a href=
-  "../graph/doc/incremental_components.html"><tt>incremental_connected_components()</tt></a>
+  "incremental_components.html"><tt>incremental_connected_components()</tt></a>
   <hr>
   <pre>
 disjoint_sets_with_storage&lt;ID,InverseID,FindCompress&gt;
@@ -181,7 +181,7 @@ disjoint_sets_with_storage&lt;ID,InverseID,FindCompress&gt;
   The rank and parent properties are initialized during construction so the
   each element is in a set by itself (so it is not necessary to initialize
   objects of this class with the <a href=
-  "../graph/doc/incremental_components.html#sec:initialize-incremental-components">
+  "incremental_components.html#sec:initialize-incremental-components">
   <tt>initialize_incremental_components()</tt></a> function). This class is
   especially useful when computing the (dynamic) connected components of an
   <tt>edge_list</tt> graph which does not provide a place to store vertex

doc/grid_graph.html

@@ -69,7 +69,7 @@
     <p>
       Defined in
       <a href="../../../boost/graph/grid_graph.hpp"><tt>boost/graph/grid_graph.hpp</tt></a>
-      with all functions in the <tt>boost</tt> namespace.  A simple examples of creating and iterating over a grid_graph is available here <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_example.cpp</tt></a>. An example of adding properties to a grid_graph is also available <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_properties.cpp</tt></a>
+      with all functions in the <tt>boost</tt> namespace.  A simple examples of creating and iterating over a grid_graph is available here <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_example.cpp</tt></a>. An example of adding properties to a grid_graph is also available <a href="../../../libs/graph/example/grid_graph_properties.cpp"><tt>libs/graph/example/grid_graph_properties.cpp</tt></a>
     </p>
 
     <h4>Template Parameters</h4>

doc/hawick_circuits.html

@@ -13,13 +13,13 @@
 <h1 id="hawick_circuits"><code>hawick_circuits</code></h1>
 
 <pre><code>template &lt;typename Graph, typename Visitor, typename VertexIndexMap&gt;
-void hawick_circuits(Graph const&amp; graph, Visitor visitor, VertexIndexMap const&amp; vim = get(vertex_index, graph));
+void hawick_circuits(Graph const&amp; graph, Visitor visitor, VertexIndexMap const&amp; vim = get(vertex_index, graph), unsigned int max_length = 0);
 
 template &lt;typename Graph, typename Visitor, typename VertexIndexMap&gt;
-void hawick_unique_circuits(Graph const&amp; graph, Visitor visitor, VertexIndexMap const&amp; vim = get(vertex_index, graph));
+void hawick_unique_circuits(Graph const&amp; graph, Visitor visitor, VertexIndexMap const&amp; vim = get(vertex_index, graph), unsigned int max_length = 0);
 </code></pre>
 
-<p>Enumerate all the elementary circuits in a directed multigraph. Specifically,
+<p>Enumerate all the elementary circuits (of length &le; <code>max_length</code>, if nonzero) in a directed multigraph. Specifically,
 self-loops and redundant circuits caused by parallel edges are enumerated too.
 <code>hawick_unique_circuits</code> may be used if redundant circuits caused by parallel
 edges are not desired.</p>
@@ -59,6 +59,12 @@ edges are not desired.</p>
   the vertex index map provided by the <code>graph</code>.</p>
 </blockquote>
 
+<p><strong>IN:</strong> <code>unsigned int max_length = 0</code></p>
+
+<blockquote>
+  <p>The maximum circuit length to consider. Beyond this it truncates the depth-first search, reducing the computation time by ignoring longer circuits. The default value of <code>max_length = 0</code> implies no maximum.</p>
+</blockquote>
+
 <hr />
 
 <div class="footer">

doc/incremental_components.html

@@ -43,7 +43,7 @@ the situation where edges are both added and removed from the graph,
 hence it is called <b><i>incremental</i></b><a
 href="bibliography.html#eppstein97:dynamic_graph">[42]</a> (and not
 fully dynamic). The disjoint-sets class is described in Section <A
-HREF="../../disjoint_sets/disjoint_sets.html">Disjoint Sets</A>.
+HREF="disjoint_sets.html">Disjoint Sets</A>.
 
 <P>
 The following five operations are the primary functions that you will

doc/isomorphism.html

@@ -92,8 +92,8 @@ href="./VertexListGraph.html">Vertex List Graph</a>.
 
 OUT: <tt>isomorphism_map(IsoMap f)</tt>
 <blockquote>
-The mapping from vertices in graph 1 to vertices in graph 2. This must
-be a <a href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+The mapping from vertices in graph 1 to vertices in graph 2. <tt>IsoMap</tt>
+must be a <a href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write 
 Property Map</a>.<br> <b>Default:</b> an <a
 href="../../property_map/doc/iterator_property_map.html"><tt>iterator_property_map</tt></a>
 constructed from a <tt>std::vector</tt> of graph 2's vertex
@@ -111,12 +111,11 @@ This mapping can be used either to speed up the search (as is done by the
 default value, which requires that the degrees of <i>v1</i> and <i>v2</i> are
 equal) or to impose extra conditions on the result.  The
 <tt>VertexInvariant1</tt> and <tt>VertexInvariant2</tt> types must model <a
-href="http://www.boost.org/sgi/stl/UnaryFunction.html">UnaryFunction</a>, with
-the argument type of <tt>vertex_invariant1</tt> being <tt>Graph1</tt>'s vertex
+href="http://www.boost.org/sgi/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>,
+with the argument type of <tt>vertex_invariant1</tt> being <tt>Graph1</tt>'s vertex
 descriptor type, the argument type of <tt>vertex_invariant2</tt> being
-<tt>Graph2</tt>'s vertex descriptor type, and both functions having integral
-result types.  The values returned by these two functions must be in the range
-[0, <tt>vertex_max_invariant</tt>).
+<tt>Graph2</tt>'s vertex descriptor type, and both functions sharing a 
+result type that is totally ordered and hashable, such as an integer.
 <br>
 <b>Default:</b> <tt>degree_vertex_invariant</tt> for both arguments<br>
 <b>Python</b>: Unsupported parameter.
@@ -124,14 +123,8 @@ result types.  The values returned by these two functions must be in the range
 
 IN: <tt>vertex_max_invariant(std::size_t max_invariant)</tt>
 <blockquote>
-An upper bound on the possible values returned from either
-vertex_invariant1 or vertex_invariant2.
-<br>
-<b>Default:</b> <tt>vertex_invariant2.max()</tt>. The default
-<tt>vertex_invariant2</tt> parameter, an instance of
-<tt>degree_vertex_invariant</tt>, defines this function to
-return <tt>num_vertices(g2) * (num_vertices(g2)+1)</tt>.<br>
-<b>Python</b>: Unsupported parameter.
+This parameter is ignored as it is no longer necessary, but kept for backwards
+compatibility.
 </blockquote>
 
 IN: <tt>vertex_index1_map(VertexIndex1Map i1_map)</tt>

doc/maximum_weighted_matching.html

@@ -1,5 +1,6 @@
 <html><head><!--
      Copyright 2018 Yi Ji
+     Copyright 2025 Joris van Rantwijk
 
      Use, modification and distribution is subject to the Boost Software
      License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -20,6 +21,9 @@ void maximum_weighted_matching(const Graph&amp; g, MateMap mate);
 template &lt;typename Graph, typename MateMap, typename VertexIndexMap&gt;
 void maximum_weighted_matching(const Graph&amp; g, MateMap mate, VertexIndexMap vm);
 
+template &lt;typename Graph, typename MateMap, typename VertexIndexMap, typename EdgeWeightMap&gt;
+void maximum_weighted_matching(const Graph&amp; g, MateMap mate, VertexIndexMap vm, EdgeWeightMap weights);
+
 template &lt;typename Graph, typename MateMap&gt;
 void brute_force_maximum_weighted_matching(const Graph&amp; g, MateMap mate);
 
@@ -56,77 +60,126 @@ maximum weighted matching in any undirected graph. The matching is returned in a
 <a href="../../property_map/doc/ReadWritePropertyMap.html">ReadWritePropertyMap</a>
 that maps vertices to vertices. In the mapping returned, each vertex is either mapped
 to the vertex it's matched to, or to <tt>graph_traits&lt;Graph&gt;::null_vertex()</tt> if it
-doesn't participate in the matching. If no <tt>VertexIndexMap</tt> is provided, both functions
-assume that the <tt>VertexIndexMap</tt> is provided as an internal graph property accessible
-by calling <tt>get(vertex_index, g)</tt>.
+doesn't participate in the matching.
+</p>
+
+<h3>Algorithm Description</h3>
 
 <p>
-The maximum weighted matching problem was solved by Edmonds in [<a href="bibliography.html#edmonds65:_max_weighted_match">74</a>].
-The implementation of <tt>maximum_weighted_matching</tt> followed Chapter 6, Section 10 of [<a href="bibliography.html#lawler76:_comb_opt">20</a>] and
-was written in a consistent style with <tt>edmonds_maximum_cardinality_matching</tt> because of their algorithmic similarity.
-In addition, a brute-force verifier <tt>brute_force_maximum_weighted_matching</tt> simply searches all possible matchings in any graph and selects one with the maximum weight sum.
-
-</p><h3>Algorithm Description</h3>
-
-Primal-dual method in linear programming is introduced to solve weighted matching problems. Edmonds proved that for any graph,
-the maximum number of edges in a matching is equal to the minimum capacity of an odd-set cover; this further enable us to prove a max-min duality theorem for weighted matching.
-Let <i>H<sub>k-1</sub></i> denote any graph obtained from G by contracting odd sets of three or more nodes and deleting single nodes,
-where the capacity of the family of odd sets (not necessarily a cover of G) is <i>k-1</i>. Let <i>X<sub>k</sub></i> denote any matching containing <i>k</i> edges.
-Each edge <i>(i, j)</i> has a weight <i>w<sub>ij</sub></i>. We have:
-<math>
-max<i><sub>X<sub>k</sub></sub></i> min {<i>w<sub>ij</sub>|(i, j) ϵ X<sub>k</sub></i>} = min<i><sub>H<sub>k-1</sub></sub></i> max {<i>w<sub>ij</sub>|(i, j) ϵ H<sub>k-1</sub></i>}.
-</math>
-This matching duality theorem gives an indication of how the matching problem should be formulated as a linear programming problem. That is,
-the theorem suggests a set of linear inequalities which are satisfied by any matching, and it is anticipated that these inequalities describe a convex polyhedron
-with integer vertices corresponding to feasible matchings.
+The maximum weighted matching problem was solved by Edmonds in
+[<a href="bibliography.html#edmonds65:_max_weighted_match">74</a>].
+Subsequently, Gabow [<a href="bibliography.html#gabow76">75</a>] and
+Lawler [<a href="bibliography.html#lawler76:_comb_opt">20</a>] developed methods
+to reduce the run time from <i>O(V<sup>4</sup>)</i> to <i>O(V<sup>3</sup>)</i>.
+The implementation of <tt>maximum_weighted_matching</tt> follows a description
+of the <i>O(V<sup>3</sup>)</i> algorithm by Galil [<a href="bibliography.html#galil86">77</a>].
+</p>
 
 <p>
-For <tt>maximum_weighted_matching</tt>, the management of blossoms is much more involved than in the case of <tt>max_cardinality_matching</tt>.
-It is not sufficient to record only the outermost blossoms. When an outermost blossom is expanded,
-it is necessary to know which blossom are nested immediately with it, so that these blossoms can be restored to the status of the outermost blossoms.
-When augmentation occurs, blossoms with strictly positive dual variables must be maintained for use in the next application of the labeling procedure.
+Starting from an empty matching, the algorithm repeatedly augments the matching until no further improvement is possible.
+Alternating trees and blossoms are used to find an augmenting path, in a way that is similar to maximum cardinality matching.
+A linear programming technique is used to ensure that the selected augmenting path has maximum weight.
+This involves assigning dual variables to vertices and blossoms, and computing slack values for edges.
+</p>
 
 <p>
-The outline of the algorithm is as follow:
+The outline of the algorithm is as follows:
+</p>
 
 <ol start="0">
-<li>Start with an empty matching and initialize dual variables as a half of maximum edge weight.</li>
-<li>(Labeling) Root an alternate tree at each exposed node, and proceed to construct alternate trees by labeling, using only edges with zero slack value.
+<li>Start with an empty matching and initialize dual variables to half of the maximum edge weight.</li>
+<li>(Labeling) Root a tree at each non-matched vertex, and proceed to construct alternating trees by labeling, using only edges with zero slack value.
 If an augmenting path is found, go to step 2. If a blossom is formed, go to step 3. Otherwise, go to step 4. </li>
-<li>(Augmentation) Find the augmenting path, tracing the path through shrunken blossoms. Augment the matching,
-correct labels on nodes in the augmenting path, expand blossoms with zero dual variables and remove labels from all base nodes. Go to step 1.</li>
-<li>(Blossoming) Determine the membership and base node of the new blossom and supply missing labels for all non-base nodes in the blossom.
+<li>(Augmentation) Find the augmenting path, tracing the path through shrunken blossoms. Augment the matching.
+Deconstruct and unlabel the alternating trees traversed by the augmenting path.
+Go to step 1.</li>
+<li>(Blossoming) Identify the blossoms in the alternating cycle and shrink these into a newly formed blossom.
 Return to step 1.</li>
-<li>(Revision of Dual Solution) Adjust the dual variables based on the primal-dual method. Go to step 1 or halt, accordingly.</li>
+<li>(Updating dual variables) Adjust the dual variables based on the primal-dual method.
+If this enables further growth of the alternating trees, return to step 1.
+Otherwise, halt the algorithm; the matching has maximum weight.</li>
 </ol>
 
-Note that in <tt>maximum_weighted_matching</tt>, all edge weights are multiplied by 4, so that all dual variables always remain as integers if all edge weights are integers.
-Unlike <tt>max_cardinality_matching</tt>, the initial matching and augmenting path finder are not parameterized,
-because the algorithm maintains blossoms, dual variables and node labels across all augmentations.
+<p>
+The implementation deviates from the description in [<a href="bibliography.html#galil86">77</a>] on a few points:
+</p>
 
-The algorithm's time complexity is reduced from <i>O(V<sup>4</sup>)</i> (naive implementation of [<a href="bibliography.html#edmonds65:_max_weighted_match">74</a>])
-to <i>O(V<sup>3</sup>)</i>, by a delicate labeling procedure [<a href="bibliography.html#gabow76">75</a>] to avoid re-scanning labels after revision of the dual solution.
-Special variables <i>pi, tau, gamma</i> and two arrays <i>critical_edge, tau_idx</i> are introduced for this purpose.
-Please refer to [<a href="bibliography.html#lawler76:_comb_opt">20</a>] and code comments for more implementation details.
+<ul>
+<li>
+After augmenting the matching, [<a href="bibliography.html#galil86">77</a>] expands all blossoms with zero dual.
+This is correct but potentially unnecessary; some of the expanded blossoms will be recreated during the next stage.
+The implementation holds off on the expansion of such blossoms.
+In any scenario where a blossom <i>must</i> be expanded to make progress, label T will be assigned to it.
+At that point, the blossom will be expanded through a zero-delta dual step.
+The additional cost is <i>O(V)</i> per expanded blossom, and the total number of blossom expansions is <i>O(V<sup>2</sup>)</i>,
+therefore this does not change the overall time complexity of the algorithm.
+</li>
+<li>
+The algorithm records a minimum-slack edge <i>e<sub>k,l</sub></i> for every pair of blossoms <i>B<sub>k</sub>, B<sub>l</sub></i>.
+Storing these edges in a 2-dimensional array would increase the space complexity to <i>O(V<sup>2</sup>)</i>;
+an unfortunate cost for large sparse graphs.
+The implementation of <tt>maximum_weighted_matching</tt> avoids this by maintaining, for each blossom <i>B<sub>k</sub></i>,
+a list <tt>B<sub>k</sub>.best_edge_set</tt> that contains the non-empty elements of <i>e<sub>k,l</sub></i>,
+plus edges between <i>B<sub>k</sub></i> and <i>B<sub>l</sub></i> discovered after shrinking <i>B<sub>k</sub></i>.
+The combined length of these lists is <i>O(E)</i>, since any edge is contained in at most two lists.
+The algorithm only ever examines <i>e<sub>k,l</sub></i> during the process of merging <i>B<sub>k</sub></i> into a larger blossom.
+In that case, it sequentially examines <i>e<sub>k,l</sub></i> for all <i>l</i>, taking time <i>O(V)</i>.
+The implementation handles this by examining every element of <tt>B<sub>k</sub>.best_edge_set</tt>,
+taking time <i>O(V)</i> plus a constant time per newly discovered edge.
+This does not change the overall time complexity of the algorithm.
+</li>
+<li>
+After augmenting, [<a href="bibliography.html#galil86">77</a>] removes all labels and alternating trees.
+This keeps the algorithm simple, but it causes many trees and labels to be rediscovered at the beginning of the new stage.
+To avoid such redundent work, <tt>maximum_weighted_matching</tt> removes labels only from the two alternating trees that are touched by the augmenting path.
+All other labels and trees are reused in the next stage.
+Erasing labels from a subset of the graph, requires updating the data structures that track minimum-slack edges.
+This involves examining all edges that either touch a blossom which loses its label or touch a vertex which depended on a lost label.
+These steps take <i>O(V + E)</i> per stage, adding up to <i>O(V<sup>3</sup>)</i> in total.
+Although this strategy does not improve the worst-case time complexity of the algorithm, it achieves a significant speedup in benchmarks on random graphs.
+</li>
+</ul>
+
+<p>
+If edge weights are integers, the algorithm uses only integer computations.
+This is achieved by internally multiplying edge weights by 2, which ensures that all dual variables are also integers.
+</p>
+
+<p>
+A brute-force implementation <tt>brute_force_maximum_weighted_matching</tt> is also provided.
+This algorithm simply searches all possible matchings and selects one with the maximum weight sum.
+</p>
 
 </p><h3>Where Defined</h3>
 
 <p>
 <a href="../../../boost/graph/maximum_weighted_matching.hpp"><tt>boost/graph/maximum_weighted_matching.hpp</tt></a>
+</p>
 
-</p><h3>Parameters</h3>
+<h3>Parameters</h3>
 
 IN: <tt>const Graph&amp; g</tt>
 <blockquote>
 An undirected graph. The graph type must be a model of
 <a href="VertexAndEdgeListGraph.html">Vertex and Edge List Graph</a> and
 <a href="IncidenceGraph.html">Incidence Graph</a>.
-The edge property of the graph <tt>property_map&lt;Graph, edge_weight_t&gt;</tt> must exist and have numeric value type.<br>
+The graph may not contain parallel edges.
 </blockquote>
 
 IN: <tt>VertexIndexMap vm</tt>
 <blockquote>
-Must be a model of <a href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>, mapping vertices to integer indices.
+Must be a model of <a href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>,
+mapping vertices to integer indices in the range <tt>[0, num_vertices(g))</tt>.
+If this parameter is not explicitly specified, it is obtained from the internal vertex property of the graph
+by calling <tt>get(vertex_index, g)</tt>.
+</blockquote>
+
+IN: <tt>EdgeWeightMap weights</tt>
+<blockquote>
+Must be a model of <a href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>, mapping edges to weights.
+Edge weights must be integers or floating point values.
+If this parameter is not explicitly specified, it is obtained from the internal edge property of the graph
+by calling <tt>get(edge_weight, g)</tt>.
 </blockquote>
 
 OUT: <tt>MateMap mate</tt>
@@ -140,24 +193,29 @@ vertices to vertices. For any vertex v in the graph, <tt>get(mate,v)</tt> will b
 
 <p>
 Let <i>m</i> and <i>n</i> be the number of edges and vertices in the input graph, respectively. Assuming the
-<tt>VertexIndexMap</tt> supplied allows constant-time lookup, the time complexity for
-<tt>maximum_weighted_matching</tt> is <i>O(n<sup>3</sup>)</i>. For <tt>brute_force_maximum_weighted_matching</tt>, the time complexity is exponential of <i>m</i>.
+<tt>VertexIndexMap</tt> and <tt>EdgeWeightMap</tt> both provide constant-time lookup, the time complexity for
+<tt>maximum_weighted_matching</tt> is <i>O(n<sup>3</sup>)</i>.
+For <tt>brute_force_maximum_weighted_matching</tt>, the time complexity is exponential in <i>m</i>.
+</p>
+
+<p>
 Note that the best known time complexity for maximum weighted matching in general graph
 is <i>O(nm+n<sup>2</sup>log(n))</i> by [<a href="bibliography.html#gabow90">76</a>], but relies on an
 efficient algorithm for solving nearest ancestor problem on trees, which is not provided in Boost C++ libraries.
-</p><p>
+</p>
 
-</p><h3>Example</h3>
+<h3>Example</h3>
 
-<p> The file <a href="../example/weighted_matching_example.cpp"><tt>example/weighted_matching_example.cpp</tt></a>
+<p>The file <a href="../example/weighted_matching_example.cpp"><tt>example/weighted_matching_example.cpp</tt></a>
 contains an example.
+</p>
 
-<br>
-</p><hr>
+<hr>
 <table>
 <tbody><tr valign="top">
-<td nowrap="nowrap">Copyright © 2018</td><td>
-Yi Ji (<a href="mailto:jiy@pku.edu.cn">jiy@pku.edu.cn</a>)<br>
+<td nowrap="nowrap">Copyright © 2018, 2025</td><td>
+Yi Ji (<a href="mailto:jiy@pku.edu.cn">jiy@pku.edu.cn</a>),
+Joris van Rantwijk
 </td></tr></tbody></table>
 
 </body></html>

doc/publications.html

@@ -19,7 +19,7 @@
 
 <ul>
 
-<li><a href="http://www.ddj.com/articles/2000/0009/0009toc.htm">Dr. Dobb's Sept. 2000 Article</a></a></li>
+<li><a href="https://jacobfilipp.com/DrDobbs/articles/DDJ/2000/0009/0009b/0009b.htm">Dr. Dobb's Sept. 2000 Article</a></a></li>
 <li><a href="http://www.acm.org/pubs/citations/proceedings/oops/320384/p399-siek/">OOPSLA'99 GGCL Paper</a></li>
 <li>Lie-Quan Lee's Master's Thesis about GGCL<a href="https://web.archive.org/web/20030824105142/http://www.lsc.nd.edu/downloads/research/ggcl/papers/thesis.ps">(ps)</a> <a href="https://web.archive.org/web/20030824113405/http://www.lsc.nd.edu/downloads/research/ggcl/papers/thesis.pdf">(pdf)</a></li>
 <li><a href="http://www.dietmar-kuehl.de/generic-graph-algorithms.pdf">Dietmar K&uuml;hl's Master's Thesis: Design Pattern for the Implementation of Graph Algorithms</a></li>

doc/r_c_shortest_paths.html

@@ -57,7 +57,7 @@ void r_c_shortest_paths( const Graph& g,
                          typename graph_traits<Graph>::vertex_descriptor s,
                          typename graph_traits<Graph>::vertex_descriptor t,
                          std::vector<typename graph_traits<Graph>::edge_descriptor>& pareto_optimal_solution,
-                         Resource_Container>& pareto_optimal_resource_container,
+                         Resource_Container& pareto_optimal_resource_container,
                          const Resource_Container& rc,
                          const Resource_Extension_Function& ref,
                          const Dominance_Function& dominance,
@@ -93,7 +93,7 @@ void r_c_shortest_paths( const Graph& g,
                          typename graph_traits<Graph>::vertex_descriptor s,
                          typename graph_traits<Graph>::vertex_descriptor t,
                          std::vector<typename graph_traits<Graph>::edge_descriptor>& pareto_optimal_solution,
-                         Resource_Container>& pareto_optimal_resource_container,
+                         Resource_Container& pareto_optimal_resource_container,
                          const Resource_Container& rc,
                          const Resource_Extension_Function& ref,
                          const Dominance_Function& dominance )
@@ -329,6 +329,11 @@ If <tt>vis</tt> is an object of a type modelling the ResourceConstrainedShortest
 <table border>
 <tr>
 <td>
+<tt>vis.on_enter_loop(const Queue&amp; queue, const Graph&amp; g )</tt>
+</td>
+</tr>
+<tr>
+<td>
 <tt>vis.on_label_popped( const Label&amp; l, const Graph&amp; g )</tt>
 </td>
 </tr>
@@ -353,7 +358,7 @@ If <tt>vis</tt> is an object of a type modelling the ResourceConstrainedShortest
 </td>
 </tr>
 </table>
-See the <a href="#Label">description of the Label concept</a> for the interface of a Label. See the <a href="#FunctionsDescription">algorithm description</a> for information on when these functions are called.
+Note that <i>on_enter_loop</i> returns a boolean that signals whether the main loop should continue (see the <i>default_r_c_shortest_paths_visitor</i> in the <a href="../../../boost/graph/r_c_shortest_paths.hpp"><tt>source code</tt></a> for inspiration). See the <a href="#Label">description of the Label concept</a> for the interface of a Label. See the <a href="#FunctionsDescription">algorithm description</a> for information on when these functions are called.
 <p>
 
 <a name="FunctionsDescription"><h3>Functions Description</h3></a>
@@ -554,7 +559,7 @@ When <tt>b_result_must_be_equal_to_desired_final_resource_levels==true</tt> (<tt
 
 <p>
 The file <a href="../example/r_c_shortest_paths_example.cpp">
-<rr>example/r_c_shortest_paths_example.cpp</tt></a> provides examples for how SPPRCs can be solved with the <tt>r_c_shortest_paths</tt> functions. There is an example for an SPP without resource constraints and an example for a shortest path problem with time windows.<br>
+<tt>example/r_c_shortest_paths_example.cpp</tt></a> provides examples for how SPPRCs can be solved with the <tt>r_c_shortest_paths</tt> functions. There is an example for an SPP without resource constraints and an example for a shortest path problem with time windows.<br>
 It is obvious that one would not use the algorithm for SPPs without resource constraints, because there are faster algorithms for this problem, but one would expect a code for the SPP with resource constraints to be able to handle such a case.
 </p>
 

doc/read_graphviz.html

@@ -181,8 +181,8 @@ bool status = read_graphviz(gvgraph,graph,dp,"node_id");
 <div class="section" id="building-the-graphviz-readers">
 <h1><a class="toc-backref" href="#id5">Building the GraphViz Readers</a></h1>
 <p>To use the GraphViz readers, you will need to build and link against
-the &quot;boost_graph&quot; and &quot;boost_regex&quot; libraries. These libraries can be built by following the
-<a class="reference external" href="../../../more/getting_started.html#Build_Install">Boost Jam Build Instructions</a> for the subdirectories <tt class="docutils literal"><span class="pre">libs/graph/build</span></tt> and <tt class="docutils literal"><span class="pre">libs/regex/build</span></tt>.</p>
+the &quot;boost_graph&quot; library. This library can be built by following the
+<a class="reference external" href="../../../more/getting_started.html#Build_Install">Boost Jam Build Instructions</a> for the subdirectory <tt class="docutils literal"><span class="pre">libs/graph/build</span></tt>.</p>
 </div>
 <div class="section" id="notes">
 <h1><a class="toc-backref" href="#id6">Notes</a></h1>

doc/read_graphviz.rst

@@ -182,8 +182,8 @@ GraphViz reader to populate an ``adjacency_list`` graph
 Building the GraphViz Readers
 -----------------------------
 To use the GraphViz readers, you will need to build and link against
-the "boost_graph" and "boost_regex" libraries. These libraries can be built by following the
-`Boost Jam Build Instructions`_ for the subdirectories ``libs/graph/build`` and ``libs/regex/build``.
+the "boost_graph" library. This library can be built by following the
+`Boost Jam Build Instructions`_ for the subdirectory ``libs/graph/build``.
 
 
 Notes

doc/reverse_graph.html

@@ -33,7 +33,7 @@ way to obtain a transposed view of a graph.
 <H3>Example</H3>
 
 The example from <a
-href="../example/reverse-graph-eg.cpp"><tt>examples/reverse-graph-eg.cpp</tt></a>.
+href="../example/reverse_graph.cpp"><tt>example/reverse_graph.cpp</tt></a>.
 
 <pre>
 int

doc/using_adjacency_list.html

@@ -133,7 +133,7 @@ out-edges for the whole graph.
 <PRE>
 vertex()
 </PRE>
-This operation is constant time for <TT>vecS</TT> and  for
+This operation is constant time for <TT>vecS</TT> and <i>O(V)</i> for
 <TT>listS</TT>.
 
 </ul>

example/Jamfile.v2

@@ -3,12 +3,17 @@
 # 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)
 
-import ../../config/checks/config : requires ;
+require-b2 5.0.1 ;
+import-search /boost/config/checks ;
+
+import config : requires ;
 import modules ;
 import path ;
 
 path-constant TEST_DIR : . ;
 
+project : requirements <library>/boost/graph//boost_graph ;
+
 run accum-compile-times.cpp : $(TEST_DIR)/makefile-dependencies.dat $(TEST_DIR)/makefile-target-names.dat $(TEST_DIR)/target-compile-costs.dat ;
 exe actor_clustering : actor_clustering.cpp ;
 run adj_list_ra_edgelist.cpp ;
@@ -75,15 +80,15 @@ run filtered_graph.cpp ;
 run filtered_graph_edge_range.cpp ;
 run filtered_vec_as_graph.cpp ;
 run filtered-copy-example.cpp ;
-exe fr_layout : fr_layout.cpp : [ requires cxx11_noexcept cxx11_rvalue_references sfinae_expr cxx11_auto_declarations cxx11_lambdas cxx11_unified_initialization_syntax cxx11_hdr_tuple cxx11_hdr_initializer_list cxx11_hdr_chrono cxx11_thread_local cxx11_constexpr cxx11_nullptr cxx11_numeric_limits cxx11_decltype cxx11_hdr_array cxx11_hdr_atomic cxx11_hdr_type_traits cxx11_allocator cxx11_explicit_conversion_operators ] ;
+exe fr_layout : fr_layout.cpp /boost/timer//boost_timer : [ requires cxx11_noexcept cxx11_rvalue_references sfinae_expr cxx11_auto_declarations cxx11_lambdas cxx11_unified_initialization_syntax cxx11_hdr_tuple cxx11_hdr_initializer_list cxx11_hdr_chrono cxx11_thread_local cxx11_constexpr cxx11_nullptr cxx11_numeric_limits cxx11_decltype cxx11_hdr_array cxx11_hdr_atomic cxx11_hdr_type_traits cxx11_allocator cxx11_explicit_conversion_operators ] ;
 run gerdemann.cpp ;
 run graph.cpp ;
 run graph_as_tree.cpp ;
 run graph_property.cpp ;
 run graph-assoc-types.cpp ;
 run graph-property-iter-eg.cpp ;
-run graph-thingie.cpp ../build//boost_graph ;
-run graphviz.cpp ../build//boost_graph : $(TEST_DIR)/graphviz_example.dot ;
+run graph-thingie.cpp /boost/graph//boost_graph ;
+run graphviz.cpp /boost/graph//boost_graph : $(TEST_DIR)/graphviz_example.dot ;
 run grid_graph_example.cpp ;
 run grid_graph_properties.cpp ;
 exe hawick_circuits : hawick_circuits.cpp ;
@@ -114,7 +119,7 @@ exe mean_geodesic : mean_geodesic.cpp ;
 exe minimum_degree_ordering : minimum_degree_ordering.cpp ;
 run modify_graph.cpp ;
 run neighbor_bfs.cpp ;
-run ospf-example.cpp ../build//boost_graph : $(TEST_DIR)/figs/ospf-graph.dot $(TEST_DIR)/figs/ospf-sptree.dot $(TEST_DIR)/routing-table.dat ;
+run ospf-example.cpp /boost/graph//boost_graph : $(TEST_DIR)/figs/ospf-graph.dot $(TEST_DIR)/figs/ospf-sptree.dot $(TEST_DIR)/routing-table.dat ;
 run parallel-compile-time.cpp : $(TEST_DIR)/makefile-dependencies.dat $(TEST_DIR)/makefile-target-names.dat $(TEST_DIR)/target-compile-costs.dat ;
 run planar_face_traversal.cpp ;
 run prim-example.cpp ;
@@ -129,7 +134,7 @@ run put-get-helper-eg.cpp ;
 run quick_tour.cpp ;
 run quick-tour.cpp ;
 run r_c_shortest_paths_example.cpp ;
-run read_graphviz.cpp ../build//boost_graph ;
+run read_graphviz.cpp /boost/graph//boost_graph ;
 exe read_write_dimacs : read_write_dimacs-eg.cpp ;
 run remove_edge_if_bidir.cpp ;
 run remove_edge_if_dir.cpp ;
@@ -163,6 +168,7 @@ run vertex-name-property.cpp : $(TEST_DIR)/makefile-dependencies.dat $(TEST_DIR)
 run vf2_sub_graph_iso_example.cpp ;
 run vf2_sub_graph_iso_multi_example.cpp ;
 run visitor.cpp ;
+run weighted_matching_example.cpp ;
 run write_graphviz.cpp ;
 
 #
@@ -207,7 +213,7 @@ explicit girth ;
 #run edge-connectivity.cpp ;
 #
 # These compile, but still use the old graphviz interface and die and runtime:
-# run strong_components.cpp ../build//boost_graph ;
+# run strong_components.cpp /boost/graph//boost_graph ;
 
 
 #

example/accum-compile-times.cpp

@@ -72,12 +72,8 @@ int main(int argc, const char** argv)
     file_dep_graph2 g(input_begin, input_end, n_vertices);
 #endif
 
-    typedef property_map< file_dep_graph2, vertex_name_t >::type name_map_t;
-    typedef property_map< file_dep_graph2, vertex_compile_cost_t >::type
-        compile_cost_map_t;
-
-    name_map_t name_map = get(vertex_name, g);
-    compile_cost_map_t compile_cost_map = get(vertex_compile_cost, g);
+    auto name_map = get(vertex_name, g);
+    auto compile_cost_map = get(vertex_compile_cost, g);
 
     std::ifstream name_in(argc >= 3 ? argv[2] : "makefile-target-names.dat");
     std::ifstream compile_cost_in(

example/actor_clustering.cpp

@@ -52,13 +52,13 @@ void load_actor_graph(std::istream& in, ActorGraph& g)
         // Map from the actor numbers on this line to the actor vertices
         typedef tokenizer< char_separator< char > > Tok;
         Tok tok(line, char_separator< char >(" "));
-        for (Tok::iterator id = tok.begin(); id != tok.end(); ++id)
+        for (auto const & id : tok)
         {
-            int actor_id = lexical_cast< int >(*id);
-            std::map< int, Vertex >::iterator v = actors.find(actor_id);
+            auto actor_id = lexical_cast< int >(id);
+            auto v = actors.find(actor_id);
             if (v == actors.end())
             {
-                Vertex new_vertex = add_vertex(Actor(actor_id), g);
+                auto new_vertex = add_vertex(Actor(actor_id), g);
                 actors[actor_id] = new_vertex;
                 actors_in_movie.push_back(new_vertex);
             }
@@ -68,11 +68,9 @@ void load_actor_graph(std::istream& in, ActorGraph& g)
             }
         }
 
-        for (std::vector< Vertex >::iterator i = actors_in_movie.begin();
-             i != actors_in_movie.end(); ++i)
+        for (auto i = actors_in_movie.begin(); i != actors_in_movie.end(); ++i)
         {
-            for (std::vector< Vertex >::iterator j = i + 1;
-                 j != actors_in_movie.end(); ++j)
+            for (auto j = i + 1; j != actors_in_movie.end(); ++j)
             {
                 if (!edge(*i, *j, g).second)
                     add_edge(*i, *j, g);
@@ -86,16 +84,14 @@ std::ostream& write_pajek_graph(std::ostream& out, const Graph& g,
     VertexIndexMap vertex_index, VertexNameMap vertex_name)
 {
     out << "*Vertices " << num_vertices(g) << '\n';
-    typedef typename graph_traits< Graph >::vertex_iterator vertex_iterator;
-    for (vertex_iterator v = vertices(g).first; v != vertices(g).second; ++v)
+    for (auto v = vertices(g).first; v != vertices(g).second; ++v)
     {
         out << get(vertex_index, *v) + 1 << " \"" << get(vertex_name, *v)
             << "\"\n";
     }
 
     out << "*Edges\n";
-    typedef typename graph_traits< Graph >::edge_iterator edge_iterator;
-    for (edge_iterator e = edges(g).first; e != edges(g).second; ++e)
+    for (auto e = edges(g).first; e != edges(g).second; ++e)
     {
         out << get(vertex_index, source(*e, g)) + 1 << ' '
             << get(vertex_index, target(*e, g)) + 1 << " 1.0\n"; // HACK!

example/adjacency_list.cpp

@@ -61,10 +61,8 @@ int main(int, char*[])
     const int V = 5;
     Graph g(V);
 
-    property_map< Graph, std::size_t VertexProperties::* >::type id
-        = get(&VertexProperties::index, g);
-    property_map< Graph, std::string EdgeProperties::* >::type name
-        = get(&EdgeProperties::name, g);
+    auto id = get(&VertexProperties::index, g);
+    auto name = get(&EdgeProperties::name, g);
 
     boost::graph_traits< Graph >::vertex_iterator vi, viend;
     int vnum = 0;

example/astar-cities.cpp

@@ -86,8 +86,8 @@ public:
     distance_heuristic(LocMap l, Vertex goal) : m_location(l), m_goal(goal) {}
     CostType operator()(Vertex u)
     {
-        CostType dx = m_location[m_goal].x - m_location[u].x;
-        CostType dy = m_location[m_goal].y - m_location[u].y;
+        auto dx = m_location[m_goal].x - m_location[u].x;
+        auto dy = m_location[m_goal].y - m_location[u].y;
         return ::sqrt(dx * dx + dy * dy);
     }
 
@@ -174,7 +174,7 @@ int main(int argc, char** argv)
 
     // create graph
     mygraph_t g(N);
-    WeightMap weightmap = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
     for (std::size_t j = 0; j < num_edges; ++j)
     {
         edge_descriptor e;
@@ -185,9 +185,9 @@ int main(int argc, char** argv)
     }
 
     // pick random start/goal
-    boost::mt19937 gen(std::time(0));
-    vertex start = random_vertex(g, gen);
-    vertex goal = random_vertex(g, gen);
+    boost::mt19937 gen(time(0));
+    auto start = random_vertex(g, gen);
+    auto goal = random_vertex(g, gen);
 
     cout << "Start vertex: " << name[start] << endl;
     cout << "Goal vertex: " << name[goal] << endl;
@@ -215,7 +215,7 @@ int main(int argc, char** argv)
     catch (found_goal fg)
     { // found a path to the goal
         list< vertex > shortest_path;
-        for (vertex v = goal;; v = p[v])
+        for (auto v = goal;; v = p[v])
         {
             shortest_path.push_front(v);
             if (p[v] == v)
@@ -223,7 +223,7 @@ int main(int argc, char** argv)
         }
         cout << "Shortest path from " << name[start] << " to " << name[goal]
              << ": ";
-        list< vertex >::iterator spi = shortest_path.begin();
+        auto spi = shortest_path.begin();
         cout << name[start];
         for (++spi; spi != shortest_path.end(); ++spi)
             cout << " -> " << name[*spi];

example/astar_maze.cpp

@@ -201,8 +201,8 @@ bool maze::solve()
     dist_map distance;
     boost::associative_property_map< dist_map > dist_pmap(distance);
 
-    vertex_descriptor s = source();
-    vertex_descriptor g = goal();
+    auto s = source();
+    auto g = goal();
     euclidean_heuristic heuristic(g);
     astar_goal_visitor visitor(g);
 
@@ -218,7 +218,7 @@ bool maze::solve()
     {
         // Walk backwards from the goal through the predecessor chain adding
         // vertices to the solution path.
-        for (vertex_descriptor u = g; u != s; u = predecessor[u])
+        for (auto u = g; u != s; u = predecessor[u])
             m_solution.insert(u);
         m_solution.insert(s);
         m_solution_length = distance[g];
@@ -285,9 +285,9 @@ std::size_t random_int(std::size_t a, std::size_t b)
 // Generate a maze with a random assignment of barriers.
 void random_maze(maze& m)
 {
-    vertices_size_type n = num_vertices(m.m_grid);
-    vertex_descriptor s = m.source();
-    vertex_descriptor g = m.goal();
+    auto n = num_vertices(m.m_grid);
+    auto s = m.source();
+    auto g = m.goal();
     // One quarter of the cells in the maze should be barriers.
     int barriers = n / 4;
     while (barriers > 0)
@@ -297,7 +297,7 @@ void random_maze(maze& m)
         // Walls range up to one quarter the dimension length in this direction.
         vertices_size_type wall = random_int(1, m.length(direction) / 4);
         // Create the wall while decrementing the total barrier count.
-        vertex_descriptor u = vertex(random_int(0, n - 1), m.m_grid);
+        auto u = vertex(random_int(0, n - 1), m.m_grid);
         while (wall)
         {
             // Start and goal spaces should never be barriers.
@@ -310,7 +310,7 @@ void random_maze(maze& m)
                     barriers--;
                 }
             }
-            vertex_descriptor v = m.m_grid.next(u, direction);
+            auto v = m.m_grid.next(u, direction);
             // Stop creating this wall if we reached the maze's edge.
             if (u == v)
                 break;

example/bellman-example.cpp

@@ -23,8 +23,7 @@ template < typename Graph, typename ParentMap > struct edge_writer
     void operator()(std::ostream& out, const Edge& e) const
     {
         out << "[label=\"" << get(edge_weight, m_g, e) << "\"";
-        typename graph_traits< Graph >::vertex_descriptor u = source(e, m_g),
-                                                          v = target(e, m_g);
+        auto u = source(e, m_g), v = target(e, m_g);
         if (m_parent[v] == u)
             out << ", color=\"black\"";
         else
@@ -74,8 +73,7 @@ int main()
     Graph g(edge_array, edge_array + n_edges, N);
 #endif
     graph_traits< Graph >::edge_iterator ei, ei_end;
-    property_map< Graph, int EdgeProperties::* >::type weight_pmap
-        = get(&EdgeProperties::weight, g);
+    auto weight_pmap = get(&EdgeProperties::weight, g);
     int i = 0;
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)
         weight_pmap[*ei] = weight[i];
@@ -115,9 +113,8 @@ int main()
     {
         for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
         {
-            graph_traits< Graph >::edge_descriptor e = *ei;
-            graph_traits< Graph >::vertex_descriptor u = source(e, g),
-                                                     v = target(e, g);
+            auto e = *ei;
+            auto u = source(e, g), v = target(e, g);
             // VC++ doesn't like the 3-argument get function, so here
             // we workaround by using 2-nested get()'s.
             dot_file << name[u] << " -> " << name[v] << "[label=\""

example/bellman-ford-internet.cpp

@@ -25,19 +25,18 @@ int main()
         H,
         n_vertices
     };
-    const int n_edges = 11;
     typedef std::pair< int, int > Edge;
 
     // The list of connections between routers stored in an array.
-    Edge edges[] = { Edge(A, B), Edge(A, C), Edge(B, D), Edge(B, E), Edge(C, E),
-        Edge(C, F), Edge(D, H), Edge(D, E), Edge(E, H), Edge(F, G),
+    Edge edges[] = { Edge(A, B), Edge(A, C), Edge(B, D), Edge(B, E),
+        Edge(C, E), Edge(C, F), Edge(D, H), Edge(D, E), Edge(E, H), Edge(F, G),
         Edge(G, H) };
 
     // Specify the graph type and declare a graph object
     typedef edge_list< Edge*, Edge, std::ptrdiff_t,
         std::random_access_iterator_tag >
         Graph;
-    Graph g(edges, edges + n_edges);
+    Graph g(std::begin(edges), std::end(edges));
 
     // The transmission delay values for each edge.
     float delay[] = { 5.0, 1.0, 1.3, 3.0, 10.0, 2.0, 6.3, 0.4, 1.3, 1.2, 0.5 };

example/bfs-example2.cpp

@@ -81,7 +81,7 @@ int main()
     Size time = 0;
     typedef property_map< graph_t, std::size_t VertexProps::* >::type
         dtime_map_t;
-    dtime_map_t dtime_map = get(&VertexProps::discover_time, g);
+    auto dtime_map = get(&VertexProps::discover_time, g);
     bfs_time_visitor< dtime_map_t > vis(dtime_map, time);
     breadth_first_search(
         g, vertex(s, g), color_map(get(&VertexProps::color, g)).visitor(vis));

example/bfs-name-printer.cpp

@@ -16,16 +16,15 @@ template < typename Graph, typename VertexNameMap, typename TransDelayMap >
 void build_router_network(
     Graph& g, VertexNameMap name_map, TransDelayMap delay_map)
 {
-    typename graph_traits< Graph >::vertex_descriptor a, b, c, d, e;
-    a = add_vertex(g);
+    auto a = add_vertex(g);
     name_map[a] = 'a';
-    b = add_vertex(g);
+    auto b = add_vertex(g);
     name_map[b] = 'b';
-    c = add_vertex(g);
+    auto c = add_vertex(g);
     name_map[c] = 'c';
-    d = add_vertex(g);
+    auto d = add_vertex(g);
     name_map[d] = 'd';
-    e = add_vertex(g);
+    auto e = add_vertex(g);
     name_map[e] = 'e';
 
     typename graph_traits< Graph >::edge_descriptor ed;
@@ -78,13 +77,13 @@ int main()
     typedef adjacency_list< listS, vecS, directedS, VP, EP > graph_t;
     graph_t g;
 
-    property_map< graph_t, char VP::* >::type name_map = get(&VP::name, g);
-    property_map< graph_t, double EP::* >::type delay_map = get(&EP::weight, g);
+    auto name_map = get(&VP::name, g);
+    auto delay_map = get(&EP::weight, g);
 
     build_router_network(g, name_map, delay_map);
 
     typedef property_map< graph_t, char VP::* >::type VertexNameMap;
-    graph_traits< graph_t >::vertex_descriptor a = *vertices(g).first;
+    auto a = *vertices(g).first;
     bfs_name_printer< VertexNameMap > vis(name_map);
     std::cout << "BFS vertex discover order: ";
     breadth_first_search(g, a, visitor(vis));

example/bfs.cpp

@@ -129,7 +129,7 @@ int main(int, char*[])
     std::fill_n(d, 5, 0);
 
     // The source vertex
-    Vertex s = *(boost::vertices(G).first);
+    auto s = *(boost::vertices(G).first);
     p[s] = s;
     boost::breadth_first_search(G, s,
         boost::visitor(boost::make_bfs_visitor(

example/bfs_neighbor.cpp

@@ -123,7 +123,7 @@ int main(int, char*[])
     std::fill_n(d, 5, 0);
 
     // The source vertex
-    Vertex s = *(boost::vertices(G).first);
+    auto s = *(boost::vertices(G).first);
     p[s] = s;
     boost::neighbor_breadth_first_search(G, s,
         boost::visitor(boost::make_neighbor_bfs_visitor(

example/biconnected_components.cpp

@@ -45,10 +45,9 @@ int main()
     add_edge(6, 7, g);
     add_edge(7, 8, g);
 
-    property_map< graph_t, edge_component_t >::type component
-        = get(edge_component, g);
+    auto component = get(edge_component, g);
 
-    std::size_t num_comps = biconnected_components(g, component);
+    auto num_comps = biconnected_components(g, component);
     std::cerr << "Found " << num_comps << " biconnected components.\n";
 
     std::vector< vertex_t > art_points;

example/boost_web_graph.cpp

@@ -29,9 +29,8 @@ public:
     void tree_edge(
         typename boost::graph_traits< Graph >::edge_descriptor e, Graph& g)
     {
-        typename boost::graph_traits< Graph >::vertex_descriptor u, v;
-        u = boost::source(e, g);
-        v = boost::target(e, g);
+        auto u = boost::source(e, g);
+        auto v = boost::target(e, g);
         distance[v] = distance[u] + 1;
     }
 
@@ -95,9 +94,8 @@ int main(int argc, const char** argv)
     NameVertexMap name2vertex;
     Graph g;
 
-    typedef property_map< Graph, vertex_name_t >::type NameMap;
-    NameMap node_name = get(vertex_name, g);
-    property_map< Graph, edge_name_t >::type link_name = get(edge_name, g);
+    auto node_name = get(vertex_name, g);
+    auto link_name = get(edge_name, g);
 
     //===========================================================================
     // Read the data file and construct the graph.
@@ -113,7 +111,7 @@ int main(int argc, const char** argv)
         bool inserted;
         Vertex u, v;
 
-        std::list< std::string >::iterator i = line_toks.begin();
+        auto i = line_toks.begin();
 
         boost::tie(pos, inserted)
             = name2vertex.insert(std::make_pair(*i, Vertex()));
@@ -210,6 +208,8 @@ int main(int argc, const char** argv)
     // the tree nodes in the order that we want to print out:
     // a directory-structure like format.
     std::vector< size_type > dfs_distances(num_vertices(g), 0);
+
+    using NameMap = property_map< Graph, vertex_name_t >::type;
     print_tree_visitor< NameMap, size_type* > tree_printer(
         node_name, &dfs_distances[0]);
     for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)

example/boykov_kolmogorov-eg.cpp

@@ -85,17 +85,15 @@ int main()
         Graph;
 
     Graph g;
-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
+    auto capacity = get(edge_capacity, g);
+    auto residual_capacity = get(edge_residual_capacity, g);
+    auto rev = get(edge_reverse, g);
     Traits::vertex_descriptor s, t;
     read_dimacs_max_flow(g, capacity, rev, s, t);
 
     std::vector< default_color_type > color(num_vertices(g));
     std::vector< long > distance(num_vertices(g));
-    long flow = boykov_kolmogorov_max_flow(g, s, t);
+    auto flow = boykov_kolmogorov_max_flow(g, s, t);
 
     std::cout << "c  The total flow:" << std::endl;
     std::cout << "s " << flow << std::endl << std::endl;

example/bron_kerbosch_clique_number.cpp

@@ -29,7 +29,7 @@ int main(int argc, char* argv[])
     read_graph(g, cin);
 
     // Use the Bron-Kerbosch algorithm to find all cliques, and
-    size_t c = bron_kerbosch_clique_number(g);
+    auto c = bron_kerbosch_clique_number(g);
     cout << "clique number: " << c << endl;
 
     return 0;

example/bucket_sorter.cpp

@@ -47,7 +47,7 @@ int main()
             cout << " has number ";
             do
             {
-                int v = my_bucket_sorter[j].top();
+                auto v = my_bucket_sorter[j].top();
                 my_bucket_sorter[j].pop();
                 cout << v << " ";
             } while (!my_bucket_sorter[j].empty());
@@ -75,7 +75,7 @@ int main()
             cout << " has number ";
             do
             {
-                int v = my_bucket_sorter[j].top();
+                auto v = my_bucket_sorter[j].top();
                 my_bucket_sorter[j].pop();
                 cout << v << " ";
             } while (!my_bucket_sorter[j].empty());
@@ -93,7 +93,7 @@ int main()
         std::size_t current = rand() % N;
         if (!my_bucket_sorter[current].empty())
         {
-            int v = my_bucket_sorter[current].top();
+            auto v = my_bucket_sorter[current].top();
             my_bucket_sorter[current].pop();
             bucket[v] = rand() % N;
             my_bucket_sorter.push(v);
@@ -105,7 +105,7 @@ int main()
         std::size_t current = rand() % N;
         if (!my_bucket_sorter[current].empty())
         {
-            int v = my_bucket_sorter[current].top();
+            auto v = my_bucket_sorter[current].top();
             bucket[v] = rand() % N;
             my_bucket_sorter.update(v);
         }

example/canonical_ordering.cpp

@@ -44,7 +44,7 @@ int main(int argc, char** argv)
     add_edge(1, 5, g);
 
     // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
     graph_traits< graph >::edges_size_type edge_count = 0;
     graph_traits< graph >::edge_iterator ei, ei_end;
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
@@ -69,10 +69,9 @@ int main(int argc, char** argv)
         make_iterator_property_map(embedding.begin(), get(vertex_index, g)),
         std::back_inserter(ordering));
 
-    ordering_storage_t::iterator oi, oi_end;
-    oi_end = ordering.end();
+    auto oi_end = ordering.end();
     std::cout << "The planar canonical ordering is: ";
-    for (oi = ordering.begin(); oi != oi_end; ++oi)
+    for (auto oi = ordering.begin(); oi != oi_end; ++oi)
         std::cout << *oi << " ";
     std::cout << std::endl;
 

example/cc-internet.cpp

@@ -32,8 +32,7 @@ int main()
         make_iterator_property_map(
             component.begin(), get(vertex_index, g), component[0]));
 
-    property_map< GraphvizGraph, vertex_attribute_t >::type vertex_attr_map
-        = get(vertex_attribute, g);
+    auto vertex_attr_map = get(vertex_attribute, g);
     std::string color[] = { "white", "gray", "black", "lightgray" };
     graph_traits< GraphvizGraph >::vertex_iterator vi, vi_end;
     for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)

example/city_visitor.cpp

@@ -137,7 +137,7 @@ int main(int, char*[])
     cout << endl;
 
     /* Get the source vertex */
-    boost::graph_traits< Graph >::vertex_descriptor s = vertex(SanJose, G);
+    auto s = vertex(SanJose, G);
 
     cout << "*** Breadth First ***" << endl;
     breadth_first_search(G, s,

example/clustering_coefficient.cpp

@@ -52,7 +52,7 @@ int main(int argc, char* argv[])
     // computation.
     ClusteringContainer coefs(num_vertices(g));
     ClusteringMap cm(coefs, g);
-    float cc = all_clustering_coefficients(g, cm);
+    auto cc = all_clustering_coefficients(g, cm);
 
     // Print the clustering coefficient of each vertex.
     graph_traits< Graph >::vertex_iterator i, end;

example/connected-components.cpp

@@ -24,7 +24,7 @@ int main()
     add_edge(2, 5, G);
 
     std::vector< int > c(num_vertices(G));
-    int num = connected_components(
+    auto num = connected_components(
         G, make_iterator_property_map(c.begin(), get(vertex_index, G), c[0]));
 
     std::cout << std::endl;

example/connected_components.cpp

@@ -49,7 +49,7 @@ int main(int, char*[])
         add_edge(2, 5, G);
 
         std::vector< int > component(num_vertices(G));
-        int num = connected_components(G, &component[0]);
+        auto num = connected_components(G, &component[0]);
 
         std::vector< int >::size_type i;
         cout << "Total number of components: " << num << endl;

example/copy-example.cpp

@@ -30,7 +30,7 @@ int main()
         N
     };
     graph_t G(N);
-    property_map< graph_t, vertex_name_t >::type name_map = get(vertex_name, G);
+    auto name_map = get(vertex_name, G);
     char name = 'a';
     graph_traits< graph_t >::vertex_iterator v, v_end;
     for (boost::tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)

example/cuthill_mckee_ordering.cpp

@@ -57,32 +57,30 @@ int main(int, char*[])
         Pair(6, 7) }; // g-h
 
     Graph G(10);
-    for (int i = 0; i < 14; ++i)
-        add_edge(edges[i].first, edges[i].second, G);
+    for (auto const& edge : edges)
+        add_edge(edge.first, edge.second, G);
 
     graph_traits< Graph >::vertex_iterator ui, ui_end;
 
-    property_map< Graph, vertex_degree_t >::type deg = get(vertex_degree, G);
+    auto deg = get(vertex_degree, G);
     for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
         deg[*ui] = degree(*ui, G);
 
-    property_map< Graph, vertex_index_t >::type index_map
-        = get(vertex_index, G);
+    auto index_map = get(vertex_index, G);
 
     std::cout << "original bandwidth: " << bandwidth(G) << std::endl;
 
     std::vector< Vertex > inv_perm(num_vertices(G));
     std::vector< size_type > perm(num_vertices(G));
     {
-        Vertex s = vertex(6, G);
+        auto s = vertex(6, G);
         // reverse cuthill_mckee_ordering
         cuthill_mckee_ordering(G, s, inv_perm.rbegin(), get(vertex_color, G),
             get(vertex_degree, G));
         cout << "Reverse Cuthill-McKee ordering starting at: " << s << endl;
         cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
         cout << endl;
 
         for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -94,15 +92,14 @@ int main(int, char*[])
                   << std::endl;
     }
     {
-        Vertex s = vertex(0, G);
+        auto s = vertex(0, G);
         // reverse cuthill_mckee_ordering
         cuthill_mckee_ordering(G, s, inv_perm.rbegin(), get(vertex_color, G),
             get(vertex_degree, G));
         cout << "Reverse Cuthill-McKee ordering starting at: " << s << endl;
         cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
         cout << endl;
 
         for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -121,9 +118,8 @@ int main(int, char*[])
 
         cout << "Reverse Cuthill-McKee ordering:" << endl;
         cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
         cout << endl;
 
         for (size_type c = 0; c != inv_perm.size(); ++c)

example/cycle_canceling_example.cpp

@@ -21,7 +21,7 @@ int main()
     boost::edmonds_karp_max_flow(g, s, t);
     boost::cycle_canceling(g);
 
-    int cost = boost::find_flow_cost(g);
+    auto cost = boost::find_flow_cost(g);
     assert(cost == 29);
     return 0;
 }

example/cycle_ratio_example.cpp

@@ -50,12 +50,9 @@ int main(int argc, char* argv[])
     ccReal_t cc; /// critical cycle
 
     grap_real_t tgr;
-    property_map< grap_real_t, vertex_index_t >::type vim
-        = get(vertex_index, tgr);
-    property_map< grap_real_t, edge_weight_t >::type ew1
-        = get(edge_weight, tgr);
-    property_map< grap_real_t, edge_weight2_t >::type ew2
-        = get(edge_weight2, tgr);
+    auto vim = get(vertex_index, tgr);
+    auto ew1 = get(edge_weight, tgr);
+    auto ew2 = get(edge_weight2, tgr);
 
     gen_rand_graph(tgr, 1000, 30000);
     cout << "Vertices number: " << num_vertices(tgr) << endl;
@@ -72,12 +69,12 @@ int main(int argc, char* argv[])
     cout << "Minimum cycle ratio is " << min_cr << endl;
     std::pair< double, double > cr(.0, .0);
     cout << "Critical cycle:\n";
-    for (ccReal_t::iterator itr = cc.begin(); itr != cc.end(); ++itr)
+    for (auto const & edge : cc)
     {
-        cr.first += ew1[*itr];
-        cr.second += ew2[*itr];
-        std::cout << "(" << vim[source(*itr, tgr)] << ","
-                  << vim[target(*itr, tgr)] << ") ";
+        cr.first += ew1[edge];
+        cr.second += ew2[edge];
+        std::cout << "(" << vim[source(edge, tgr)] << ","
+                  << vim[target(edge, tgr)] << ") ";
     }
     cout << endl;
     assert(std::abs(cr.first / cr.second - min_cr) < epsilon * 2);

example/dag_shortest_paths.cpp

@@ -50,8 +50,7 @@ int main()
     add_edge(u, x, 1, g);
     add_edge(v, x, -2, g);
 
-    property_map< graph_t, vertex_distance_t >::type d_map
-        = get(vertex_distance, g);
+    auto d_map = get(vertex_distance, g);
 
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
     // VC++ has trouble with the named-parameter mechanism, so
@@ -61,7 +60,7 @@ int main()
     default_dijkstra_visitor vis;
     std::less< int > compare;
     closed_plus< int > combine;
-    property_map< graph_t, edge_weight_t >::type w_map = get(edge_weight, g);
+    auto w_map = get(edge_weight, g);
     dag_shortest_paths(g, s, d_map, w_map, &color[0], &pred[0], vis, compare,
         combine, (std::numeric_limits< int >::max)(), 0);
 #else

example/dave.cpp

@@ -169,8 +169,7 @@ int main(int, char*[])
     };
 
     Graph G(N);
-    boost::property_map< Graph, vertex_index_t >::type vertex_id
-        = get(vertex_index, G);
+    auto vertex_id = get(vertex_index, G);
 
     std::vector< weight_t > distance(N, (numeric_limits< weight_t >::max)());
     typedef boost::graph_traits< Graph >::vertex_descriptor Vertex;

example/dijkstra-example-listS.cpp

@@ -44,13 +44,11 @@ int main(int, char*[])
     graph_traits< graph_t >::vertex_iterator i, iend;
 
     graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
-    property_map< graph_t, edge_weight_t >::type weightmap
-        = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
 
     // Manually intialize the vertex index and name maps
-    property_map< graph_t, vertex_index_t >::type indexmap
-        = get(vertex_index, g);
-    property_map< graph_t, vertex_name_t >::type name = get(vertex_name, g);
+    auto indexmap = get(vertex_index, g);
+    auto name = get(vertex_name, g);
     int c = 0;
     for (boost::tie(i, iend) = vertices(g); i != iend; ++i, ++c)
     {
@@ -58,12 +56,10 @@ int main(int, char*[])
         name[*i] = 'A' + c;
     }
 
-    vertex_descriptor s = vertex(A, g);
+    auto s = vertex(A, g);
 
-    property_map< graph_t, vertex_distance_t >::type d
-        = get(vertex_distance, g);
-    property_map< graph_t, vertex_predecessor_t >::type p
-        = get(vertex_predecessor, g);
+    auto d = get(vertex_distance, g);
+    auto p = get(vertex_predecessor, g);
     dijkstra_shortest_paths(g, s, predecessor_map(p).distance_map(d));
 
     std::cout << "distances and parents:" << std::endl;
@@ -87,9 +83,8 @@ int main(int, char*[])
     graph_traits< graph_t >::edge_iterator ei, ei_end;
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     {
-        graph_traits< graph_t >::edge_descriptor e = *ei;
-        graph_traits< graph_t >::vertex_descriptor u = source(e, g),
-                                                   v = target(e, g);
+        auto e = *ei;
+        auto u = source(e, g), v = target(e, g);
         dot_file << name[u] << " -> " << name[v] << "[label=\""
                  << get(weightmap, e) << "\"";
         if (p[v] == u)

example/dijkstra-example.cpp

@@ -39,11 +39,10 @@ int main(int, char*[])
     int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
     int num_arcs = sizeof(edge_array) / sizeof(Edge);
     graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
-    property_map< graph_t, edge_weight_t >::type weightmap
-        = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
     std::vector< vertex_descriptor > p(num_vertices(g));
     std::vector< int > d(num_vertices(g));
-    vertex_descriptor s = vertex(A, g);
+    auto s = vertex(A, g);
 
     dijkstra_shortest_paths(g, s,
         predecessor_map(boost::make_iterator_property_map(
@@ -73,9 +72,8 @@ int main(int, char*[])
     graph_traits< graph_t >::edge_iterator ei, ei_end;
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     {
-        graph_traits< graph_t >::edge_descriptor e = *ei;
-        graph_traits< graph_t >::vertex_descriptor u = source(e, g),
-                                                   v = target(e, g);
+        auto e = *ei;
+        auto u = source(e, g), v = target(e, g);
         dot_file << name[u] << " -> " << name[v] << "[label=\""
                  << get(weightmap, e) << "\"";
         if (p[v] == u)

example/dijkstra-no-color-map-example.cpp

@@ -43,11 +43,10 @@ int main(int, char*[])
     int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
     int num_arcs = sizeof(edge_array) / sizeof(Edge);
     graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
-    property_map< graph_t, edge_weight_t >::type weightmap
-        = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
     std::vector< vertex_descriptor > p(num_vertices(g));
     std::vector< int > d(num_vertices(g));
-    vertex_descriptor s = vertex(A, g);
+    auto s = vertex(A, g);
 
     dijkstra_shortest_paths_no_color_map(g, s,
         predecessor_map(boost::make_iterator_property_map(
@@ -78,8 +77,7 @@ int main(int, char*[])
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     {
         graph_traits< graph_t >::edge_descriptor e = *ei;
-        graph_traits< graph_t >::vertex_descriptor u = source(e, g),
-                                                   v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
         dot_file << name[u] << " -> " << name[v] << "[label=\""
                  << get(weightmap, e) << "\"";
         if (p[v] == u)

example/directed_graph.cpp

@@ -18,8 +18,8 @@ int main(int, char*[])
 
     typedef boost::directed_graph<> Graph;
     Graph g;
-    boost::graph_traits< Graph >::vertex_descriptor v0 = g.add_vertex();
-    boost::graph_traits< Graph >::vertex_descriptor v1 = g.add_vertex();
+    auto v0 = g.add_vertex();
+    auto v1 = g.add_vertex();
 
     g.add_edge(v0, v1);
 

example/edge-connectivity.cpp

@@ -30,7 +30,7 @@ min_degree_vertex(Graph& g)
 {
     typename graph_traits< Graph >::vertex_descriptor p;
     typedef typename graph_traits< Graph >::degree_size_type size_type;
-    size_type delta = (std::numeric_limits< size_type >::max)();
+    auto delta = (std::numeric_limits< size_type >::max)();
     typename graph_traits< Graph >::vertex_iterator i, iend;
     for (boost::tie(i, iend) = vertices(g); i != iend; ++i)
         if (degree(*i, g) < delta)
@@ -86,12 +86,9 @@ typename graph_traits< VertexListGraph >::degree_size_type edge_connectivity(
     std::vector< edge_descriptor > pred(num_vertices(g));
 
     FlowGraph flow_g(num_vertices(g));
-    typename property_map< FlowGraph, edge_capacity_t >::type cap
-        = get(edge_capacity, flow_g);
-    typename property_map< FlowGraph, edge_residual_capacity_t >::type res_cap
-        = get(edge_residual_capacity, flow_g);
-    typename property_map< FlowGraph, edge_reverse_t >::type rev_edge
-        = get(edge_reverse, flow_g);
+    auto cap = get(edge_capacity, flow_g);
+    auto res_cap = get(edge_residual_capacity, flow_g);
+    auto rev_edge = get(edge_reverse, flow_g);
 
     typename graph_traits< VertexListGraph >::edge_iterator ei, ei_end;
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
@@ -139,14 +136,13 @@ typename graph_traits< VertexListGraph >::degree_size_type edge_connectivity(
     }
 
     std::vector< bool > in_S_star(num_vertices(g), false);
-    typename std::vector< vertex_descriptor >::iterator si;
-    for (si = S_star.begin(); si != S_star.end(); ++si)
-        in_S_star[*si] = true;
+    for (auto const& vertex : S_star.begin())
+        in_S_star[vertex] = true;
     degree_size_type c = 0;
-    for (si = S_star.begin(); si != S_star.end(); ++si)
+    for (auto const& vertex : S_star.begin())
     {
         typename graph_traits< VertexListGraph >::out_edge_iterator ei, ei_end;
-        for (boost::tie(ei, ei_end) = out_edges(*si, g); ei != ei_end; ++ei)
+        for (boost::tie(ei, ei_end) = out_edges(vertex, g); ei != ei_end; ++ei)
             if (!in_S_star[target(*ei, g)])
             {
                 *disconnecting_set++ = *ei;
@@ -166,21 +162,17 @@ int main()
     read_graphviz("figs/edge-connectivity.dot", g);
 
     typedef graph_traits< GraphvizGraph >::edge_descriptor edge_descriptor;
-    typedef graph_traits< GraphvizGraph >::degree_size_type degree_size_type;
     std::vector< edge_descriptor > disconnecting_set;
-    degree_size_type c
-        = edge_connectivity(g, std::back_inserter(disconnecting_set));
+    auto c = edge_connectivity(g, std::back_inserter(disconnecting_set));
 
     std::cout << "The edge connectivity is " << c << "." << std::endl;
 
-    property_map< GraphvizGraph, vertex_attribute_t >::type attr_map
-        = get(vertex_attribute, g);
+    auto attr_map = get(vertex_attribute, g);
 
     std::cout << "The disconnecting set is {";
-    for (std::vector< edge_descriptor >::iterator i = disconnecting_set.begin();
-         i != disconnecting_set.end(); ++i)
-        std::cout << "(" << attr_map[source(*i, g)]["label"] << ","
-                  << attr_map[target(*i, g)]["label"] << ") ";
+    for (auto const& edge : disconnecting_set)
+        std::cout << "(" << attr_map[source(edge, g)]["label"] << ","
+                  << attr_map[target(edge, g)]["label"] << ") ";
     std::cout << "}." << std::endl;
     return EXIT_SUCCESS;
 }

example/edge-function.cpp

@@ -111,12 +111,12 @@ int main(int argc, const char** argv)
 
     graph_traits< graph_type >::vertex_descriptor yow, zag, bar;
     // Get vertex name property map from the graph
-    typedef property_map< graph_type, vertex_name_t >::type name_map_t;
-    name_map_t name = get(vertex_name, g);
+    auto name = get(vertex_name, g);
     // Get iterators for the vertex set
     graph_traits< graph_type >::vertex_iterator i, end;
     boost::tie(i, end) = vertices(g);
     // Find yow.h
+    using name_map_t = property_map< graph_type, vertex_name_t >::type;
     name_equals_t< name_map_t > predicate1("yow.h", name);
     yow = *std::find_if(i, end, predicate1);
     // Find zag.o

example/edge_basics.cpp

@@ -45,12 +45,12 @@ template < class Graph > struct exercise_edge
     void operator()(Edge e) const
     {
         // begin
-        // Get the associated vertex type out of the edge using the
-        // edge_traits class
-        // Use the source() and target() functions to access the vertices
-        // that belong to Edge e
-        Vertex src = source(e, G);
-        Vertex targ = target(e, G);
+        //  Get the associated vertex type out of the edge using the
+        //  edge_traits class
+        //  Use the source() and target() functions to access the vertices
+        //  that belong to Edge e
+        auto src = source(e, G);
+        auto targ = target(e, G);
 
         // print out the vertex id's just because
         cout << "(" << src << "," << targ << ") ";

example/edge_connectivity.cpp

@@ -49,8 +49,7 @@ int main()
     typedef graph_traits< UndirectedGraph >::degree_size_type degree_size_type;
     std::vector< edge_descriptor > disconnecting_set;
 
-    degree_size_type c
-        = edge_connectivity(g, std::back_inserter(disconnecting_set));
+    auto c = edge_connectivity(g, std::back_inserter(disconnecting_set));
 
     std::cout << "The edge connectivity is " << c << "." << std::endl;
     std::cout << "The disconnecting set is {";

example/edge_iterator_constructor.cpp

@@ -60,7 +60,7 @@ public:
     }
     edge_stream_iterator operator++(int)
     {
-        edge_stream_iterator tmp = *this;
+        auto tmp = *this;
         m_read();
         return tmp;
     }

example/edge_property.cpp

@@ -80,10 +80,8 @@ template < class Graph > void print_network(const Graph& G)
         typename boost::graph_traits< Graph >::out_edge_iterator OutEdgeIter;
     typedef typename boost::graph_traits< Graph >::in_edge_iterator InEdgeIter;
 
-    typename property_map< Graph, edge_mycapacity_t >::const_type capacity
-        = get(edge_mycapacity, G);
-    typename property_map< Graph, edge_myflow_t >::const_type flow
-        = get(edge_myflow, G);
+    auto capacity = get(edge_mycapacity, G);
+    auto flow = get(edge_myflow, G);
 
     Viter ui, uiend;
     boost::tie(ui, uiend) = vertices(G);

example/edmonds-karp-eg.cpp

@@ -61,11 +61,9 @@ int main()
 
     Graph g;
 
-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
+    auto capacity = get(edge_capacity, g);
+    auto rev = get(edge_reverse, g);
+    auto residual_capacity = get(edge_residual_capacity, g);
 
     Traits::vertex_descriptor s, t;
     read_dimacs_max_flow(g, capacity, rev, s, t);

example/family_tree.cpp

@@ -38,8 +38,7 @@ int main()
 
     graph_traits< adjacency_list<> >::vertex_iterator i, end;
     graph_traits< adjacency_list<> >::adjacency_iterator ai, a_end;
-    property_map< adjacency_list<>, vertex_index_t >::type index_map
-        = get(vertex_index, g);
+    auto index_map = get(vertex_index, g);
 
     for (boost::tie(i, end) = vertices(g); i != end; ++i)
     {

example/fibonacci_heap.cpp

@@ -34,7 +34,7 @@ int main()
         uniform_int<> distrib(0, N - 1);
         boost::variate_generator< random_ns::mt19937&, uniform_int<> > rand_gen(
             gen, distrib);
-        for (int t = 0; t < 10; ++t)
+        for (std::size_t t = 0; t < 10; ++t)
         {
             std::vector< float > v, w(N);
 

example/filtered-copy-example.cpp

@@ -45,7 +45,7 @@ int main()
         N
     };
     graph_t G(N);
-    property_map< graph_t, vertex_name_t >::type name_map = get(vertex_name, G);
+    auto name_map = get(vertex_name, G);
     char name = 'a';
     graph_traits< graph_t >::vertex_iterator v, v_end;
     for (boost::tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)

example/filtered_graph_edge_range.cpp

@@ -65,7 +65,7 @@ int main()
     add_edge(D, B, 3, g);
     add_edge(E, C, 0, g);
 
-    EdgeWeightMap weight = get(edge_weight, g);
+    auto weight = get(edge_weight, g);
 
     std::cout << "unfiltered edge_range(C,D)\n";
     graph_traits< Graph >::out_edge_iterator f, l;

example/filtered_vec_as_graph.cpp

@@ -45,18 +45,15 @@ int main()
         B,
         C,
         D,
-        E,
-        N
+        E
     };
     const char* name = "ABCDE";
     typedef std::vector< std::list< int > > Graph;
-    Graph g(N);
-    g[A].push_back(B);
-    g[A].push_back(C);
-    g[C].push_back(D);
-    g[C].push_back(E);
-    g[D].push_back(E);
-    g[E].push_back(C);
+    Graph g = { { B, C }, // A
+        {}, // B
+        { D, E }, // C
+        { E }, // D
+        { C } }; // E
 
     constant_target filter(E);
     filtered_graph< Graph, constant_target > fg(g, filter);

example/fr_layout.cpp

@@ -16,7 +16,7 @@
 #include <map>
 #include <vector>
 #include <boost/random/linear_congruential.hpp>
-#include <boost/progress.hpp>
+#include <boost/timer/progress_display.hpp>
 #include <boost/shared_ptr.hpp>
 
 using namespace boost;
@@ -67,7 +67,7 @@ class progress_cooling : public linear_cooling< double >
 public:
     explicit progress_cooling(std::size_t iterations) : inherited(iterations)
     {
-        display.reset(new progress_display(iterations + 1, std::cerr));
+        display.reset(new boost::timer::progress_display(iterations + 1, std::cerr));
     }
 
     double operator()()
@@ -77,7 +77,7 @@ public:
     }
 
 private:
-    shared_ptr< boost::progress_display > display;
+    shared_ptr< boost::timer::progress_display > display;
 };
 
 int main(int argc, char* argv[])

example/gerdemann.cpp

@@ -49,14 +49,14 @@ void merge_vertex(typename boost::graph_traits< Graph >::vertex_descriptor u,
          ++out_i)
     {
         e = *out_i;
-        typename Traits::vertex_descriptor targ = target(e, g);
+        auto targ = target(e, g);
         add_edge(u, targ, getp(e), g);
     }
     typename Traits::in_edge_iterator in_i, in_end;
     for (boost::tie(in_i, in_end) = in_edges(v, g); in_i != in_end; ++in_i)
     {
         e = *in_i;
-        typename Traits::vertex_descriptor src = source(e, g);
+        auto src = source(e, g);
         add_edge(src, u, getp(e), g);
     }
     clear_vertex(v, g);
@@ -131,8 +131,8 @@ int main()
     add_edge(3, 4, EdgeProperty('h'), g);
     add_edge(0, 1, EdgeProperty('c'), g);
 
-    property_map< graph_type, vertex_index_t >::type id = get(vertex_index, g);
-    property_map< graph_type, edge_name_t >::type name = get(edge_name, g);
+    auto id = get(vertex_index, g);
+    auto name = get(edge_name, g);
 
     graph_traits< graph_type >::vertex_iterator i, end;
     graph_traits< graph_type >::out_edge_iterator ei, edge_end;

example/girth.cpp

@@ -75,7 +75,7 @@ public:
 
     void tree_edge(edge_descriptor e, Graph* g)
     {
-        vertex_descriptor u = source(e, g), v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
         k = d_map[u] + 1;
         d_map[v] = k;
         ++distance_list[k];
@@ -83,7 +83,7 @@ public:
     }
     void non_tree_edge(edge_descriptor e, Graph* g)
     {
-        vertex_descriptor u = source(e, g), v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
         k = d_map[u] + 1;
         if (d_map[v] + k < girth && v != p_map[u])
             girth = d_map[v] + k;

example/graph-thingie.cpp

@@ -14,6 +14,7 @@
 #include <boost/foreach.hpp>
 #include <string>
 #include <sstream>
+#include <cstdlib>
 
 using namespace boost;
 using namespace std;
@@ -51,18 +52,16 @@ int main()
     graph_t graph(0);
     dynamic_properties dp;
 
-    property_map< graph_t, vertex_name_t >::type vname
-        = get(vertex_name, graph);
+    auto vname = get(vertex_name, graph);
     dp.property("node_id", vname);
 
-    property_map< graph_t, vertex_label_t >::type vlabel
-        = get(vertex_label_t(), graph);
+    auto vlabel = get(vertex_label_t(), graph);
     dp.property("label", vlabel);
 
-    property_map< graph_t, vertex_root_t >::type root = get(vertex_root, graph);
+    auto root = get(vertex_root, graph);
     dp.property("root", root);
 
-    property_map< graph_t, edge_name_t >::type elabel = get(edge_name, graph);
+    auto elabel = get(edge_name, graph);
     dp.property("label", elabel);
 
     // Use ref_property_map to turn a graph property into a property map
@@ -104,5 +103,5 @@ int main()
              << get("label", dp, v) << ")\n";
     }
 
-    return 0;
+    return status ? EXIT_SUCCESS : EXIT_FAILURE;
 }

example/graph_as_tree.cpp

@@ -39,13 +39,12 @@ int main()
 
     graph_t g;
 
-    vertex_t a = add_vertex(g), b = add_vertex(g), c = add_vertex(g);
+    auto a = add_vertex(g), b = add_vertex(g), c = add_vertex(g);
 
     add_edge(a, b, g);
     add_edge(a, c, g);
 
-    typedef property_map< graph_t, vertex_name_t >::type vertex_name_map_t;
-    vertex_name_map_t name = get(vertex_name, g);
+    auto name = get(vertex_name, g);
     name[a] = "A";
     name[b] = "B";
     name[c] = "C";

example/grid_graph_properties.cpp

@@ -35,7 +35,7 @@ int main(int argc, char* argv[])
     put(dataMap, v, 2.0f);
 
     // Get the data at the node at position (0,1) in the grid
-    float retrieved = get(dataMap, v);
+    auto retrieved = get(dataMap, v);
     std::cout << "Retrieved value: " << retrieved << std::endl;
 
     return 0;

example/hawick_circuits.cpp

@@ -28,10 +28,7 @@ template < typename OutputStream > struct cycle_printer
 
         // Get the property map containing the vertex indices
         // so we can print them.
-        typedef typename boost::property_map< Graph,
-            boost::vertex_index_t >::const_type IndexMap;
-
-        IndexMap indices = get(boost::vertex_index, g);
+        auto indices = get(boost::vertex_index, g);
 
         // Iterate over path printing each vertex that forms the cycle.
         typename Path::const_iterator i, before_end = boost::prior(p.end());
@@ -78,7 +75,8 @@ int main(int argc, char const* argv[])
 {
     if (argc < 2)
     {
-        std::cout << "usage: " << argv[0] << " num_vertices < input\n";
+        std::cout << "usage: " << argv[0] << " <num_vertices>";
+        std::cout << " <max_length (optional)>\n";
         return EXIT_FAILURE;
     }
 
@@ -88,7 +86,12 @@ int main(int argc, char const* argv[])
     build_graph(graph, num_vertices, first_vertex, last_vertex);
 
     cycle_printer< std::ostream > visitor(std::cout);
-    boost::hawick_circuits(graph, visitor);
+    if (argc == 2) {
+        boost::hawick_circuits(graph, visitor);
+    } else {
+        unsigned int max_length = boost::lexical_cast< unsigned int >(argv[2]);
+        boost::hawick_circuits(graph, visitor, max_length);
+    }
 
     return EXIT_SUCCESS;
 }

example/implicit_graph.cpp

@@ -223,7 +223,7 @@ private:
         static const int ring_offset[] = { 1, -1 };
         vertex_descriptor v;
 
-        std::size_t p = *this->base_reference();
+        auto p = *this->base_reference();
         if (m_u == 0 && p == 1)
             v = m_n - 1; // Vertex n-1 precedes vertex 0.
         else

example/influence_prestige.cpp

@@ -63,7 +63,7 @@ int main(int argc, char* argv[])
     graph_traits< Graph >::vertex_iterator i, end;
     for (boost::tie(i, end) = vertices(g); i != end; ++i)
     {
-        Vertex v = *i;
+        auto v = *i;
         cout << setiosflags(ios::left) << setw(12) << g[v].name << "\t" << im[v]
              << "\t" << pm[v] << endl;
     }

example/interior_property_map.cpp

@@ -61,7 +61,7 @@ void who_owes_who(EdgeIter first, EdgeIter last, const Graph& G)
     // Access the propety acessor type for this graph
     typedef
         typename property_map< Graph, vertex_first_name_t >::const_type NamePA;
-    NamePA name = get(vertex_first_name, G);
+    auto name = get(vertex_first_name, G);
 
     typedef typename boost::property_traits< NamePA >::value_type NameType;
 

example/iohb.c

@@ -778,13 +778,13 @@ int writeHB_mat_double(const char* filename, int M, int N,
 
     if ( Ptrfmt == NULL ) Ptrfmt = "(8I10)";
     ParseIfmt(Ptrfmt,&Ptrperline,&Ptrwidth);
-    sprintf(pformat,"%%%dd",Ptrwidth);
+    snprintf(pformat, sizeof(pformat), "%%%dd", Ptrwidth);
     ptrcrd = (N+1)/Ptrperline;
     if ( (N+1)%Ptrperline != 0) ptrcrd++;
 
     if ( Indfmt == NULL ) Indfmt =  Ptrfmt;
     ParseIfmt(Indfmt,&Indperline,&Indwidth);
-    sprintf(iformat,"%%%dd",Indwidth);
+    snprintf(iformat, sizeof(iformat), "%%%dd", Indwidth);
     indcrd = nz/Indperline;
     if ( nz%Indperline != 0) indcrd++;
 
@@ -793,9 +793,9 @@ int writeHB_mat_double(const char* filename, int M, int N,
       ParseRfmt(Valfmt,&Valperline,&Valwidth,&Valprec,&Valflag);
       if (Valflag == 'D') *strchr(Valfmt,'D') = 'E';
       if (Valflag == 'F')
-         sprintf(vformat,"%% %d.%df",Valwidth,Valprec);
+          snprintf(vformat, sizeof(vformat), "%% %d.%df", Valwidth, Valprec);
       else
-         sprintf(vformat,"%% %d.%dE",Valwidth,Valprec);
+         snprintf(vformat, sizeof(vformat), "%% %d.%dE", Valwidth, Valprec);
       valcrd = nvalentries/Valperline;
       if ( nvalentries%Valperline != 0) valcrd++;
     } else valcrd = 0;
@@ -804,9 +804,9 @@ int writeHB_mat_double(const char* filename, int M, int N,
        if ( Rhsfmt == NULL ) Rhsfmt = Valfmt;
        ParseRfmt(Rhsfmt,&Rhsperline,&Rhswidth,&Rhsprec, &Rhsflag);
        if (Rhsflag == 'F')
-          sprintf(rformat,"%% %d.%df",Rhswidth,Rhsprec);
+          snprintf(rformat, sizeof(rformat), "%% %d.%df", Rhswidth, Rhsprec);
        else
-          sprintf(rformat,"%% %d.%dE",Rhswidth,Rhsprec);
+          snprintf(rformat, sizeof(rformat), "%% %d.%dE", Rhswidth, Rhsprec);
        if (Rhsflag == 'D') *strchr(Rhsfmt,'D') = 'E';
        rhscrd = nrhsentries/Rhsperline;
        if ( nrhsentries%Rhsperline != 0) rhscrd++;
@@ -1361,16 +1361,16 @@ int writeHB_mat_char(const char* filename, int M, int N,
 
     if ( Ptrfmt == NULL ) Ptrfmt = "(8I10)";
     ParseIfmt(Ptrfmt,&Ptrperline,&Ptrwidth);
-    sprintf(pformat,"%%%dd",Ptrwidth);
+    snprintf(pformat, sizeof(pformat), "%%%dd", Ptrwidth);
 
     if ( Indfmt == NULL ) Indfmt =  Ptrfmt;
     ParseIfmt(Indfmt,&Indperline,&Indwidth);
-    sprintf(iformat,"%%%dd",Indwidth);
+    snprintf(iformat, sizeof(iformat), "%%%dd", Indwidth);
 
     if ( Type[0] != 'P' ) {          /* Skip if pattern only  */
       if ( Valfmt == NULL ) Valfmt = "(4E20.13)";
       ParseRfmt(Valfmt,&Valperline,&Valwidth,&Valprec,&Valflag);
-      sprintf(vformat,"%%%ds",Valwidth);
+      snprintf(vformat, sizeof(vformat), "%%%ds", Valwidth);
     }
 
     ptrcrd = (N+1)/Ptrperline;
@@ -1385,7 +1385,7 @@ int writeHB_mat_char(const char* filename, int M, int N,
     if ( Nrhs > 0 ) {
        if ( Rhsfmt == NULL ) Rhsfmt = Valfmt;
        ParseRfmt(Rhsfmt,&Rhsperline,&Rhswidth,&Rhsprec, &Rhsflag);
-       sprintf(rformat,"%%%ds",Rhswidth);
+       snprintf(rformat, sizeof(rformat), "%%%ds", Rhswidth);
        rhscrd = nrhsentries/Rhsperline;
        if ( nrhsentries%Rhsperline != 0) rhscrd++;
        if ( Rhstype[1] == 'G' ) rhscrd+=rhscrd;

example/iteration_macros.cpp

@@ -45,8 +45,7 @@ int main()
 
     graph_traits< adjacency_list<> >::vertex_iterator i, end;
     graph_traits< adjacency_list<> >::adjacency_iterator ai, a_end;
-    property_map< adjacency_list<>, vertex_index_t >::type index_map
-        = get(vertex_index, g);
+    auto index_map = get(vertex_index, g);
 
     BGL_FORALL_VERTICES(i, g, adjacency_list<>)
     {

example/johnson-eg.cpp

@@ -36,7 +36,7 @@ int main()
     Graph g(edge_array, edge_array + E, V);
 #endif
 
-    property_map< Graph, edge_weight_t >::type w = get(edge_weight, g);
+    auto w = get(edge_weight, g);
     int weights[] = { 0, 0, 0, 0, 0, 3, -4, 8, 1, 7, 4, -5, 2, 6 };
     int* wp = weights;
 

example/kevin-bacon.cpp

@@ -58,10 +58,8 @@ int main(int argc, const char** argv)
         Graph;
     Graph g;
 
-    typedef property_map< Graph, vertex_name_t >::type actor_name_map_t;
-    actor_name_map_t actor_name = get(vertex_name, g);
-    typedef property_map< Graph, edge_name_t >::type movie_name_map_t;
-    movie_name_map_t connecting_movie = get(edge_name, g);
+    auto actor_name = get(vertex_name, g);
+    auto connecting_movie = get(edge_name, g);
 
     typedef graph_traits< Graph >::vertex_descriptor Vertex;
     typedef std::map< std::string, Vertex > NameVertexMap;

example/kevin-bacon2.cpp

@@ -65,7 +65,7 @@ public:
 
     void tree_edge(Edge e, const Graph& g) const
     {
-        Vertex u = source(e, g), v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
         d[v] = d[u] + 1;
     }
 

example/king_ordering.cpp

@@ -62,26 +62,24 @@ int main(int, char*[])
 
     graph_traits< Graph >::vertex_iterator ui, ui_end;
 
-    property_map< Graph, vertex_degree_t >::type deg = get(vertex_degree, G);
+    auto deg = get(vertex_degree, G);
     for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
         deg[*ui] = degree(*ui, G);
 
-    property_map< Graph, vertex_index_t >::type index_map
-        = get(vertex_index, G);
+    auto index_map = get(vertex_index, G);
 
     std::cout << "original bandwidth: " << bandwidth(G) << std::endl;
 
     std::vector< Vertex > inv_perm(num_vertices(G));
     std::vector< size_type > perm(num_vertices(G));
     {
-        Vertex s = vertex(6, G);
+        auto s = vertex(6, G);
         // king_ordering
         king_ordering(G, s, inv_perm.rbegin(), get(vertex_color, G),
             get(vertex_degree, G), get(vertex_index, G));
         cout << "King ordering starting at: " << s << endl;
         cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
+        for (auto i = inv_perm.begin(); i != inv_perm.end(); ++i)
             cout << index_map[*i] << " ";
         cout << endl;
 
@@ -100,9 +98,8 @@ int main(int, char*[])
             get(vertex_degree, G), get(vertex_index, G));
         cout << "King ordering starting at: " << s << endl;
         cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
         cout << endl;
 
         for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -121,9 +118,8 @@ int main(int, char*[])
 
         cout << "King ordering:" << endl;
         cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
         cout << endl;
 
         for (size_type c = 0; c != inv_perm.size(); ++c)

example/kruskal-example.cpp

@@ -26,7 +26,7 @@ int main()
     std::size_t num_edges = sizeof(edge_array) / sizeof(E);
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
     Graph g(num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, g);
+    auto = get(edge_weight, g);
     for (std::size_t j = 0; j < num_edges; ++j)
     {
         Edge e;
@@ -38,14 +38,14 @@ int main()
 #else
     Graph g(edge_array, edge_array + num_edges, weights, num_nodes);
 #endif
-    property_map< Graph, edge_weight_t >::type weight = get(edge_weight, g);
+
+    auto weight = get(edge_weight, g);
     std::vector< Edge > spanning_tree;
 
     kruskal_minimum_spanning_tree(g, std::back_inserter(spanning_tree));
 
     std::cout << "Print the edges in the MST:" << std::endl;
-    for (std::vector< Edge >::iterator ei = spanning_tree.begin();
-         ei != spanning_tree.end(); ++ei)
+    for (auto ei = spanning_tree.begin(); ei != spanning_tree.end(); ++ei)
     {
         std::cout << source(*ei, g) << " <--> " << target(*ei, g)
                   << " with weight of " << weight[*ei] << std::endl;

example/kruskal-telephone.cpp

@@ -30,8 +30,7 @@ int main()
         property< edge_weight_t, int > >
         Graph;
     Graph g(num_vertices(g_dot));
-    property_map< GraphvizGraph, edge_attribute_t >::type edge_attr_map
-        = get(edge_attribute, g_dot);
+    auto edge_attr_map = get(edge_attribute, g_dot);
     graph_traits< GraphvizGraph >::edge_iterator ei, ei_end;
     for (boost::tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei)
     {
@@ -45,22 +44,20 @@ int main()
         size_type;
     kruskal_minimum_spanning_tree(g, std::back_inserter(mst));
 
-    property_map< Graph, edge_weight_t >::type weight = get(edge_weight, g);
+    auto weight = get(edge_weight, g);
     int total_weight = 0;
-    for (size_type e = 0; e < mst.size(); ++e)
-        total_weight += get(weight, mst[e]);
+    for (auto const& edge : mst)
+        total_weight += get(weight, edge);
     std::cout << "total weight: " << total_weight << std::endl;
 
     typedef graph_traits< Graph >::vertex_descriptor Vertex;
-    for (size_type i = 0; i < mst.size(); ++i)
+    for (auto const& edge : mst)
     {
-        Vertex u = source(mst[i], g), v = target(mst[i], g);
+        auto u = source(edge, g), v = target(edge, g);
         edge_attr_map[edge(u, v, g_dot).first]["color"] = "black";
     }
     std::ofstream out("figs/telephone-mst-kruskal.dot");
-    graph_property< GraphvizGraph, graph_edge_attribute_t >::type&
-        graph_edge_attr_map
-        = get_property(g_dot, graph_edge_attribute);
+    auto graph_edge_attr_map = get_property(g_dot, graph_edge_attribute);
     graph_edge_attr_map["color"] = "gray";
     graph_edge_attr_map["style"] = "bold";
     write_graphviz(out, g_dot);

example/kuratowski_subgraph.cpp

@@ -45,7 +45,7 @@ int main(int argc, char** argv)
     add_edge(4, 5, g);
 
     // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
     graph_traits< graph >::edges_size_type edge_count = 0;
     graph_traits< graph >::edge_iterator ei, ei_end;
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)

example/last-mod-time.cpp

@@ -76,8 +76,7 @@ int main(int argc, const char** argv)
         exit(-1);
     }
     // Obtain internal property map from the graph
-    property_map< graph_type, vertex_name_t >::type name_map
-        = get(vertex_name, g);
+    auto name_map = get(vertex_name, g);
     read_graph_file(file_in, name_in, g, name_map);
 
     // Create storage for last modified times
@@ -89,7 +88,7 @@ int main(int argc, const char** argv)
     // Create last modified time property map
     iter_map_t mod_time_map(last_mod_vec.begin(), get(vertex_index, g));
 
-    property_map< graph_type, vertex_name_t >::type name = get(vertex_name, g);
+    auto name = get(vertex_name, g);
     struct stat stat_buf;
     graph_traits< graph_type >::vertex_descriptor u;
     typedef graph_traits< graph_type >::vertex_iterator vertex_iter_t;

example/leda-graph-eg.cpp

@@ -19,7 +19,7 @@ int main()
     g.new_node("Eurystheus");
     g.new_node("Amphitryon");
     typedef property_map< graph_t, vertex_all_t >::type NodeMap;
-    NodeMap node_name_map = get(vertex_all, g);
+    auto node_name_map = get(vertex_all, g);
     graph_traits< graph_t >::vertex_iterator vi, vi_end;
     for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
         std::cout << node_name_map[*vi] << std::endl;

example/loops_dfs.cpp

@@ -133,20 +133,18 @@ int main(int argc, char* argv[])
     typedef std::set< Vertex > set_t;
     typedef std::list< set_t > list_of_sets_t;
     list_of_sets_t loops;
-    Vertex entry = *vertices(g).first;
+    auto entry = *vertices(g).first;
 
     find_loops(entry, g, loops);
 
-    property_map< Graph, vertex_attribute_t >::type vattr_map
-        = get(vertex_attribute, g);
-    property_map< Graph, edge_attribute_t >::type eattr_map
-        = get(edge_attribute, g);
+    auto vattr_map = get(vertex_attribute, g);
+    auto eattr_map = get(edge_attribute, g);
     graph_traits< Graph >::edge_iterator ei, ei_end;
 
-    for (list_of_sets_t::iterator i = loops.begin(); i != loops.end(); ++i)
+    for (auto i = loops.begin(); i != loops.end(); ++i)
     {
         std::vector< bool > in_loop(num_vertices(g), false);
-        for (set_t::iterator j = (*i).begin(); j != (*i).end(); ++j)
+        for (auto j = (*i).begin(); j != (*i).end(); ++j)
         {
             vattr_map[*j]["color"] = "gray";
             in_loop[*j] = true;
@@ -167,9 +165,7 @@ int main(int argc, char* argv[])
     for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
     {
         loops_out << *vi << "[";
-        for (std::map< std::string, std::string >::iterator ai
-             = vattr_map[*vi].begin();
-             ai != vattr_map[*vi].end(); ++ai)
+        for (auto ai = vattr_map[*vi].begin(); ai != vattr_map[*vi].end(); ++ai)
         {
             loops_out << ai->first << "=" << ai->second;
             if (next(ai) != vattr_map[*vi].end())
@@ -181,10 +177,8 @@ int main(int argc, char* argv[])
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     {
         loops_out << source(*ei, g) << " -> " << target(*ei, g) << "[";
-        std::map< std::string, std::string >& attr_map = eattr_map[*ei];
-        for (std::map< std::string, std::string >::iterator eai
-             = attr_map.begin();
-             eai != attr_map.end(); ++eai)
+        auto& attr_map = eattr_map[*ei];
+        for (auto eai = attr_map.begin(); eai != attr_map.end(); ++eai)
         {
             loops_out << eai->first << "=" << eai->second;
             if (next(eai) != attr_map.end())

example/make_biconnected_planar.cpp

@@ -41,7 +41,7 @@ int main(int argc, char** argv)
     add_edge(0, 10, g);
 
     // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
     graph_traits< graph >::edges_size_type edge_count = 0;
     graph_traits< graph >::edge_iterator ei, ei_end;
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)

example/make_maximal_planar.cpp

@@ -60,7 +60,7 @@ int main(int argc, char** argv)
               << 2 * num_vertices(g) - 4 << " faces." << std::endl;
 
     // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
     graph_traits< graph >::edges_size_type edge_count = 0;
     graph_traits< graph >::edge_iterator ei, ei_end;
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)

example/matching_example.cpp

@@ -25,15 +25,14 @@ int main()
 
     const int n_vertices = 18;
 
-    std::vector< std::string > ascii_graph;
-
-    ascii_graph.push_back("           0       1---2       3       ");
-    ascii_graph.push_back("            \\     /     \\     /        ");
-    ascii_graph.push_back("             4---5       6---7         ");
-    ascii_graph.push_back("             |   |       |   |         ");
-    ascii_graph.push_back("             8---9      10---11        ");
-    ascii_graph.push_back("            /     \\     /     \\        ");
-    ascii_graph.push_back("     12   13      14---15      16   17 ");
+    std::vector< std::string > ascii_graph
+        = { "           0       1---2       3       ",
+              "            \\     /     \\     /        ",
+              "             4---5       6---7         ",
+              "             |   |       |   |         ",
+              "             8---9      10---11        ",
+              "            /     \\     /     \\        ",
+              "     12   13      14---15      16   17 " };
 
     // It has a perfect matching of size 8. There are two isolated
     // vertices that we'll use later...
@@ -75,9 +74,8 @@ int main()
 
     std::cout << "In the following graph:" << std::endl << std::endl;
 
-    for (std::vector< std::string >::iterator itr = ascii_graph.begin();
-         itr != ascii_graph.end(); ++itr)
-        std::cout << *itr << std::endl;
+    for (auto const& str : ascii_graph)
+        std::cout << str << std::endl;
 
     std::cout << std::endl
               << "Found a matching of size " << matching_size(g, &mate[0])
@@ -106,8 +104,7 @@ int main()
 
     std::cout << "In the following graph:" << std::endl << std::endl;
 
-    for (std::vector< std::string >::iterator itr = ascii_graph.begin();
-         itr != ascii_graph.end(); ++itr)
+    for (auto itr = ascii_graph.begin(); itr != ascii_graph.end(); ++itr)
         std::cout << *itr << std::endl;
 
     std::cout << std::endl

example/max_flow.cpp

@@ -62,11 +62,9 @@ int main()
 
     Graph g;
 
-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
+    auto capacity = get(edge_capacity, g);
+    auto rev = get(edge_reverse, g);
+    auto residual_capacity = get(edge_residual_capacity, g);
 
     Traits::vertex_descriptor s, t;
     read_dimacs_max_flow(g, capacity, rev, s, t);

example/mcgregor_subgraphs_example.cpp

@@ -81,14 +81,12 @@ int main(int argc, char* argv[])
         property< edge_name_t, unsigned int > >
         Graph;
 
-    typedef property_map< Graph, vertex_name_t >::type VertexNameMap;
-
     // Test maximum and unique variants on known graphs
     Graph graph_simple1, graph_simple2;
     example_callback< Graph > user_callback(graph_simple1);
 
-    VertexNameMap vname_map_simple1 = get(vertex_name, graph_simple1);
-    VertexNameMap vname_map_simple2 = get(vertex_name, graph_simple2);
+    auto vname_map_simple1 = get(vertex_name, graph_simple1);
+    auto vname_map_simple2 = get(vertex_name, graph_simple2);
 
     // Graph that looks like a triangle
     put(vname_map_simple1, add_vertex(graph_simple1), 1);

example/mean_geodesic.cpp

@@ -71,7 +71,7 @@ int main(int argc, char* argv[])
     // so-called small-world distance) as a result.
     GeodesicContainer geodesics(num_vertices(g));
     GeodesicMap gm(geodesics, g);
-    float sw = all_mean_geodesics(g, dm, gm);
+    auto sw = all_mean_geodesics(g, dm, gm);
 
     // Print the mean geodesic distance of each vertex and finally,
     // the graph itself.

example/miles_span.cpp

@@ -102,11 +102,9 @@ int main(int argc, char* argv[])
         long sp_length = 0;
 
         // Use the "z" utility field for distance.
-        typedef property_map< Graph*, z_property< long > >::type Distance;
-        Distance d = get(z_property< long >(), g);
+        auto d = get(z_property< long >(), g);
         // Use the "w" property for parent
-        typedef property_map< Graph*, w_property< Vertex* > >::type Parent;
-        Parent p = get(w_property< Vertex* >(), g);
+        auto p = get(w_property< Vertex* >(), g);
         total_length_visitor< Distance > length_vis(sp_length, d);
 
         prim_minimum_spanning_tree(g, p,

example/min_max_paths.cpp

@@ -52,14 +52,14 @@ int main(int, char*[])
     const char name[] = "abcdef";
 
     const int num_nodes = 6;
-    E edges[] = { E(0, 2), E(1, 1), E(1, 3), E(1, 4), E(2, 1), E(2, 3), E(3, 4),
-        E(4, 0), E(4, 1) };
+    const auto edges = { E(0, 2), E(1, 1), E(1, 3), E(1, 4), E(2, 1), E(2, 3),
+        E(3, 4), E(4, 0), E(4, 1) };
     int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
     const int n_edges = sizeof(edges) / sizeof(E);
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
     // VC++ can't handle iterator constructors
     Graph G(num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, G);
+    auto weightmap = get(edge_weight, G);
     for (std::size_t j = 0; j < sizeof(edges) / sizeof(E); ++j)
     {
         graph_traits< Graph >::edge_descriptor e;
@@ -68,8 +68,8 @@ int main(int, char*[])
         weightmap[e] = weights[j];
     }
 #else
-    Graph G(edges, edges + n_edges, weights, num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, G);
+    Graph G(std::begin(edges), std::end(edges), weights, num_nodes);
+    auto = get(edge_weight, G);
 #endif
 
     std::vector< Vertex > p(num_vertices(G));

example/minimum_degree_ordering.cpp

@@ -146,8 +146,7 @@ int main(int argc, char* argv[])
 
     Vector supernode_sizes(n, 1); // init has to be 1
 
-    boost::property_map< Graph, vertex_index_t >::type id
-        = get(vertex_index, G);
+    auto id = get(vertex_index, G);
 
     Vector degree(n, 0);
 

example/modify_graph.cpp

@@ -47,8 +47,7 @@ template < class MutableGraph > void modify_demo(MutableGraph& g)
     typename GraphTraits::edges_size_type m = 0;
     typename GraphTraits::vertex_descriptor u, v, w;
     edge_descriptor e, e1, e2;
-    typename property_map< MutableGraph, edge_name_t >::type name_map
-        = get(edge_name, g);
+    auto name_map = get(edge_name, g);
     bool added;
     typename GraphTraits::vertex_iterator vi, vi_end;
 

example/neighbor_bfs.cpp

@@ -65,16 +65,14 @@ public:
     template < class Edge, class Graph >
     void tree_out_edge(Edge e, const Graph& g) const
     {
-        typename graph_traits< Graph >::vertex_descriptor u = source(e, g),
-                                                          v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
         put(m_distance, v, get(m_distance, u) + 1);
         put(m_predecessor, v, u);
     }
     template < class Edge, class Graph >
     void tree_in_edge(Edge e, const Graph& g) const
     {
-        typename graph_traits< Graph >::vertex_descriptor u = source(e, g),
-                                                          v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
         put(m_distance, u, get(m_distance, v) + 1);
         put(m_predecessor, u, v);
     }