Fix a number of wrong / invalid links.

stefanseefeld · stefanseefeld · commit 63323f020f8c · 2016-03-06T14:07:23.000-05:00
diff --git a/doc/tutorial.qbk b/doc/tutorial.qbk
@@ -424,7 +424,7 @@ instances of class [^Derived]. In such cases, we use
 [^return_value_policy<manage_new_object>] to instruct Python to adopt
 the pointer to [^Base] and hold the instance in a new Python [^Base]
 object until the the Python object is destroyed. We will see more of
-Boost.Python [link python.call_policies call policies] later.
+Boost.Python [link tutorial.functions.call_policies call policies] later.
 
     // Tell Python to take ownership of factory's result
     def("factory", factory,
@@ -462,7 +462,7 @@ functions so that a Python override may be called:
     };
 
 Notice too that in addition to inheriting from `Base`, we also multiply-
-inherited `wrapper<Base>` (See [@../../../v2/wrapper.html Wrapper]). The
+inherited `wrapper<Base>` (See [@../reference/high_level_components/boost_python_wrapper_hpp.html#high_level_components.boost_python_wrapper_hpp.class_template_wrapper Wrapper]). The
 `wrapper` template makes the job of wrapping classes that are meant to
 overridden in Python, easier.
 
@@ -494,11 +494,11 @@ Methods correspond roughly to C++'s [*member functions]]
 [section Virtual Functions with Default Implementations]
 
 We've seen in the previous section how classes with pure virtual functions are
-wrapped using Boost.Python's [@../../../v2/wrapper.html class wrapper]
+wrapped using Boost.Python's [@../reference/high_level_components/boost_python_wrapper_hpp.html#high_level_components.boost_python_wrapper_hpp.class_template_wrapper class wrapper]
 facilities. If we wish to wrap [*non]-pure-virtual functions instead, the
 mechanism is a bit different.
 
-Recall that in the [link python.class_virtual_functions previous section], we
+Recall that in the [link tutorial.exposing.class_virtual_functions previous section], we
 wrapped a class with a pure virtual function that we then implemented in C++, or
 Python classes derived from it. Our base class:
 
@@ -811,7 +811,7 @@ or more policies can be composed by chaining. Here's the general syntax:
             policy3<args...> > >
 
 Here is the list of predefined call policies. A complete reference detailing
-these can be found [@../../../v2/reference.html#models_of_call_policies here].
+these can be found [@../reference/function_invocation_and_creation/models_of_callpolicies.html here].
 
 * [*with_custodian_and_ward]:  Ties lifetimes of the arguments
 * [*with_custodian_and_ward_postcall]:  Ties lifetimes of the arguments and results
@@ -896,7 +896,7 @@ to retrieve the default arguments:
     def("f", f);                            // defaults lost!
 
 Because of this, when wrapping C++ code, we had to resort to manual
-wrapping as outlined in the [link python.overloading previous section], or
+wrapping as outlined in the [link tutorial.functions.overloading previous section], or
 writing thin wrappers:
 
     // write "thin wrappers"
@@ -969,7 +969,7 @@ fourth macro argument). The thin wrappers are all enclosed in a class named
 
     .def("wack_em", &george::wack_em, george_overloads());
 
-See the [@../../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec overloads reference]
+See the [@../reference/function_invocation_and_creation/boost_python_overloads_hpp.html#function_invocation_and_creation.boost_python_overloads_hpp.macros overloads reference]
 for details.
 
 [h2 init and optional]
@@ -1036,12 +1036,12 @@ Notice though that we have a situation now where we have a minimum of zero
 It is important to emphasize however that [*the overloaded functions must
 have a common sequence of initial arguments]. Otherwise, our scheme above
 will not work. If this is not the case, we have to wrap our functions
-[link python.overloading manually].
+[link tutorial.functions.overloading manually].
 
 Actually, we can mix and match manual wrapping of overloaded functions and
 automatic wrapping through [^BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS] and
 its sister, [^BOOST_PYTHON_FUNCTION_OVERLOADS]. Following up on our example
-presented in the section [link python.overloading on overloading], since the
+presented in the section [link tutorial.functions.overloading on overloading], since the
 first 4 overload functins have a common sequence of initial arguments, we
 can use [^BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS] to automatically wrap the
 first three of the [^def]s and manually wrap just the last. Here's
@@ -1266,7 +1266,7 @@ associated with the C++ type passed as its first parameter.
 The scope is a class that has an associated global Python object which
 controls the Python namespace in which new extension classes and wrapped
 functions will be defined as attributes. Details can be found
-[@../../../v2/scope.html here].]
+[@../reference/high_level_components/boost_python_scope_hpp.html#high_level_components.boost_python_scope_hpp.class_scope here].]
 
 You can access those values in Python as
 
@@ -1402,8 +1402,8 @@ There is a difference however. While the reference-counting is fully
 automatic in Python, the Python C API requires you to do it
 [@http://www.python.org/doc/current/c-api/refcounting.html by hand]. This is
 messy and especially hard to get right in the presence of C++ exceptions.
-Fortunately Boost.Python provides the [@../../../v2/handle.html handle] and
-[@../../../v2/object.html object] class templates to automate the process.
+Fortunately Boost.Python provides the [@../reference/utility_and_infrastructure/boost_python_handle_hpp.html#utility_and_infrastructure.boost_python_handle_hpp.class_template_handle handle] and
+[@../reference/object_wrappers/boost_python_object_hpp.html#object_wrappers.boost_python_object_hpp.class_object object] class templates to automate the process.
 
 [h2 Running Python code]
 
@@ -1446,7 +1446,7 @@ containing a phrase that is well-known in programming circles.
 
 Often we'd like to have a class to manipulate Python objects.
 But we have already seen such a class above, and in the
-[@python/object.html previous section]: the aptly named [^object] class
+[link tutorial.object previous section]: the aptly named [^object] class
 and its derivatives. We've already seen that they can be constructed from
 a [^handle]. The following examples should further illustrate this fact:
 
@@ -1466,7 +1466,7 @@ which returns the result directly:
 [h2 Exception handling]
 
 If an exception occurs in the evaluation of the python expression,
-[@../../../v2/errors.html#error_already_set-spec error_already_set] is thrown:
+[@../reference/high_level_components/boost_python_errors_hpp.html#high_level_components.boost_python_errors_hpp.class_error_already_set error_already_set] is thrown:
 
     try
     {
@@ -1847,7 +1847,7 @@ we have a class [^point] in C++:
     }
 
 If we are using the technique from the previous session,
-[link python.creating_packages Creating Packages], we can code directly
+[link tutorial.techniques.creating_packages Creating Packages], we can code directly
 into [^geom/\_\_init\_\_.py]:
 
 [python]
@@ -1970,13 +1970,9 @@ This method is recommended too if you are developing the C++ library and
 exporting it to Python at the same time: changes in a class will only demand
 the compilation of a single cpp, instead of the entire wrapper code.
 
-[note If you're exporting your classes with [@../../../../pyste/index.html Pyste],
-take a look at the [^--multiple] option, that generates the wrappers in
-various files as demonstrated here.]
-
 [note This method is useful too if you are getting the error message
 ['"fatal error C1204:Compiler limit:internal structure overflow"] when compiling
-a large source file, as explained in the [@../../../v2/faq.html#c1204 FAQ].]
+a large source file, as explained in the [@../faq/fatal_error_c1204_compiler_limit.html FAQ].]
 
 [endsect]
 [endsect] [/ General Techniques]
