Skip to content

basic_facade_builder::build

using build = /* see below */;

Specifies a facade type deduced from the template parameters of basic_facade_builder<Cs, Rs, C>. Specifically,

  • typename build::convention_types is defined as Cs, and
  • typename build::reflection_types is defined as Rs, and
  • build::constraints is a core constant expression of type proxiable_ptr_constraints that defines constraints to the pointer types, and
  • build::constraints.max_size is C::max_size if defined by restrict_layout, otherwise sizeof(void*) * 2u when C::max_size is default-size, and
  • build::constraints.max_align is C::max_align if defined by restrict_layout, otherwise alignof(void*) when C::max_align is default-size, and
  • build::constraints.copyability is C::copyability if defined by support_copy, otherwise constraint_level::none when C::copyability is default-cl, and
  • build::constraints.relocatability is C::relocatability if defined by support_rellocation, otherwise constraint_level::nothrow when C::relocatability is default-cl, and
  • build::constraints.destructibility is C::destructibility if defined by support_destruction, otherwise constraint_level::nothrow when C::destructibility is default-cl.

The definition of type build makes use of the following exposition-only function:

consteval proxiable_ptr_constraints normalize(proxiable_ptr_constraints value) {
  if (value.max_size == default-size)
      { value.max_size = sizeof(void*) * 2u; }
  if (value.max_align == default-size)
      { value.max_align = alignof(void*); }
  if (value.copyability == default-cl)
      { value.copyability = constraint_level::none; }
  if (value.relocatability == default-cl)
      { value.relocatability = constraint_level::nothrow; }
  if (value.destructibility == default-cl)
      { value.destructibility = constraint_level::nothrow; }
  return value;
}

Member Types

Name Definition
convention_types Cs
reflection_types Rs

Member Constants

Name Definition
constraints [static] [constexpr] normalize(C)

Notes

It is encouraged to inherit build with an empty struct before specifying a proxy, rather than using or typedef the build type into an alias, to improve compilation performance.

The default values of the fields of proxiable_ptr_constraints are based on our engineering practices. The default values of max_size and max_alignment are usually sufficient for many implementations of fancy pointers, such as std::unique_ptr, std::shared_ptr, and boost::interprocess::offset_ptr. A larger combination of size and alignment ensures better compatibility with the implementation of the underlying pointers and reduces heap allocation when the element type fits in the buffer (see function template make_proxy), at the cost of making the corresponding proxy objects larger.

Example

#include <type_traits>

#include <proxy/proxy.h>

struct DefaultBase : pro::facade_builder
    ::build {};

struct CopyableBase : pro::facade_builder
    ::support_copy<pro::constraint_level::nontrivial>
    ::build {};

struct TrivialBase : pro::facade_builder
    ::support_copy<pro::constraint_level::trivial>
    ::support_relocation<pro::constraint_level::trivial>
    ::support_destruction<pro::constraint_level::trivial>
    ::restrict_layout<sizeof(void*)>
    ::build {};

int main() {
  static_assert(!std::is_copy_constructible_v<pro::proxy<DefaultBase>>);
  static_assert(std::is_nothrow_move_constructible_v<pro::proxy<DefaultBase>>);
  static_assert(std::is_nothrow_destructible_v<pro::proxy<DefaultBase>>);

  static_assert(std::is_copy_constructible_v<pro::proxy<CopyableBase>>);
  static_assert(std::is_nothrow_move_constructible_v<pro::proxy<CopyableBase>>);
  static_assert(std::is_nothrow_destructible_v<pro::proxy<CopyableBase>>);

  static_assert(std::is_trivially_copy_constructible_v<pro::proxy<TrivialBase>>);
  static_assert(std::is_trivially_move_constructible_v<pro::proxy<TrivialBase>>);
  static_assert(std::is_trivially_destructible_v<pro::proxy<TrivialBase>>);
}

See Also