basic_domain -> domain, doc

Author: jll63

doc/basic_domain.adoc

@@ -1,5 +1,5 @@
 
-## basic_domain
+## domain
 
 ### Synopsis
 
@@ -9,7 +9,7 @@ Defined in <boost/openmethod/policies/core.hpp>.
 namespace boost::openmethod::policies {
 
 template<class Policy>
-struct basic_domain {
+struct domain {
     template<class Class> static vptr_type static_vptr;
     // unspecified members
 };
@@ -19,7 +19,7 @@ struct basic_domain {
 
 ### Description
 
-`basic_domain` is a registry of classes and methods registered in a _Policy_,
+`domain` is a registry of classes and methods registered in a _Policy_,
 and their dispatch tables.
 
 ### Members

doc/basic_policy.adoc

@@ -6,11 +6,13 @@
 Defined in <boost/openmethod/policies/core.hpp>.
 
 ```c++
-namespace boost::openmethod::policies {
+namespace boost::openmethod {
+
+namespace policies {
 
 template<class Policy, class... Facets>
 struct basic_policy : virtual abstract_policy,
-                      virtual basic_domain<Policy>,
+                      virtual domain<Policy>,
                       virtual Facets... {
     template<class Facet>
     static constexpr bool has_facet = /*unspecified*/;
@@ -28,7 +30,19 @@ struct basic_policy : virtual abstract_policy,
     using remove = /*unspecified*/;
 };
 
-}
+struct release : basic_policy<release, ...> {};
+
+struct debug : release::add<...> {};
+
+} // policies
+
+#ifdef NDEBUG
+using default_policy = policies::release;
+#else
+using default_policy = policies::debug;
+#endif
+
+} // boost::openmethod
 ```
 
 ### Description
@@ -101,3 +115,30 @@ It is not an error if _policy_ does not contain such a facet; in that case, the
 new policy contains the same facet as the original one.
 
 The original policy and the new one share static variables.
+
+### Non-members
+
+#### release
+
+```c++
+struct release;
+```
+
+A policy that contains facet implementations `std_rtti`, `fast_perfect_hash`,
+`vptr_vector` and `vectored_error_handler`.
+
+#### debug
+
+```c++
+struct debug;
+```
+
+The `release` policy with additional facet implementations `runtime_checks`,
+`basic_error_output` and basic_trace_output.
+
+NOTE: `debug` extends `release` but it does not a fork it. Both policies use the
+same `domain`.
+
+#### default_policy
+
+An alias for `release` if `NDEBUG` is defined, and for `debug` otherwise.

doc/reference.adoc

@@ -23,7 +23,7 @@ include::virtual_ptr.adoc[]
 include::virtual_ptr_traits.adoc[]
 
 include::abstract_policy.adoc[]
-include::basic_domain.adoc[]
+include::.adoc[]
 include::basic_policy.adoc[]
 include::rtti.adoc[]
 include::std_rtti.adoc[]

doc/type_hash.adoc

@@ -70,6 +70,10 @@ static auto hash_type_id(type_id type) -> type_id;
 Returns `(type * M) >> S`, where `M` and `S` are factors found by
 `hash_initialize`.
 
+If the policy has a `runtime_checks` facet, `hash_type_id` checks that `type`
+corresponds to a registered class. If not, it reports a `unknown_class_error`
+using the policy's error_handler facet, if present, then calls `abort`.
+
 #### hash_initialize
 
 ```c++
@@ -79,3 +83,10 @@ auto hash_initialize(ForwardIterator first, ForwardIterator last) -> Report;
 
 Finds factors `M` and `S` such that `hash_type_id` is a collision-free hash
 function.
+
+If no such factors cannot be found, `hash_initialize` reports a
+`hash_search_error` using the policy's error_handler facet, if present, the
+calls `abort`.
+
+If the policy has a `trace_output` facet, `hash_initialize` uses it to write a
+summary of the search.

include/boost/openmethod/policies/core.hpp

@@ -60,10 +60,10 @@ struct debug;
 struct release;
 
 // -----------------------------------------------------------------------------
-// basic_domain
+// domain
 
 template<class Policy>
-struct basic_domain {
+struct domain {
     static detail::class_catalog classes;
     static detail::method_catalog methods;
     template<class Class>
@@ -72,17 +72,17 @@ struct basic_domain {
 };
 
 template<class Policy>
-detail::class_catalog basic_domain<Policy>::classes;
+detail::class_catalog domain<Policy>::classes;
 
 template<class Policy>
-detail::method_catalog basic_domain<Policy>::methods;
+detail::method_catalog domain<Policy>::methods;
 
 template<class Policy>
 template<class Class>
-vptr_type basic_domain<Policy>::static_vptr;
+vptr_type domain<Policy>::static_vptr;
 
 template<class Policy>
-std::vector<std::uintptr_t> basic_domain<Policy>::dispatch_data;
+std::vector<std::uintptr_t> domain<Policy>::dispatch_data;
 
 template<typename Policy, class Facet>
 struct rebind_facet {
@@ -98,7 +98,7 @@ struct rebind_facet<NewPolicy, GenericFacet<OldPolicy, Args...>> {
 
 template<class Policy, class... Facets>
 struct basic_policy : virtual abstract_policy,
-                      virtual basic_domain<Policy>,
+                      virtual domain<Policy>,
                       virtual Facets... {
     using facets = detail::types<Facets...>;
 

include/boost/openmethod/policies/fast_perfect_hash.hpp

@@ -20,7 +20,6 @@ class fast_perfect_hash : type_hash {
 
     static type_id hash_mult;
     static std::size_t hash_shift;
-    static std::size_t hash_span;
     static std::size_t hash_min;
     static std::size_t hash_max;
     static std::vector<type_id> control;
@@ -104,7 +103,6 @@ void fast_perfect_hash<Policy>::hash_initialize(
         bool found = false;
         std::size_t attempts = 0;
         buckets.resize(hash_size);
-        hash_span = 0;
 
         while (!found && attempts < 100000) {
             std::fill(buckets.begin(), buckets.end(), static_cast<type_id>(-1));
@@ -160,7 +158,7 @@ void fast_perfect_hash<Policy>::hash_initialize(
 
 template<class Policy>
 void fast_perfect_hash<Policy>::check(std::size_t index, type_id type) {
-    if (index >= hash_span || control[index] != type) {
+    if (index < hash_min || index >= hash_max || control[index] != type) {
         if constexpr (Policy::template has_facet<error_handler>) {
             unknown_class_error error;
             error.type = type;
@@ -176,8 +174,6 @@ type_id fast_perfect_hash<Policy>::hash_mult;
 template<class Policy>
 std::size_t fast_perfect_hash<Policy>::hash_shift;
 template<class Policy>
-std::size_t fast_perfect_hash<Policy>::hash_span;
-template<class Policy>
 std::size_t fast_perfect_hash<Policy>::hash_min;
 template<class Policy>
 std::size_t fast_perfect_hash<Policy>::hash_max;