Boost.Flyweight flyweight 参考

Boost.Flyweight 参考

Boost.Flyweight 参考

键值轻量级对象

目录

• 头文件 "boost/flyweight/flyweight_fwd.hpp" 概要
• 头文件 "boost/flyweight/flyweight.hpp" 概要
  • 类模板 flyweight
    • 实例化类型
    • 静态数据初始化
    • 构造函数、复制和赋值
    • 转换为底层类型
    • 修改器
    • 比较运算符
    • 专用算法
    • 哈希支持
    • 配置宏
• 头文件 "boost/flyweight/serialize.hpp" 概要
  • 序列化

头文件 "boost/flyweight/flyweight_fwd.hpp" 概要

#include <boost/functional/hash_fwd.hpp>
#include <iosfwd>

namespace boost{
  
namespace flyweights{

template<
  typename T,
  typename Arg1=implementation defined,
  typename Arg2=implementation defined,
  typename Arg3=implementation defined,
  typename Arg4=implementation defined,
  typename Arg5=implementation defined
>
class flyweight;

// comparison:

// OP is any of ==,<,!=,>,>=,<=

template<
  typename T1,typename Arg11,...,typename Arg15,
  typename T2,typename Arg21,...,typename Arg25
>
bool operator OP(
  const flyweight<T1,Arg11,...,Arg15>& x,
  const flyweight<T2,Arg21,...,Arg25>& y) noexcept(see below);

template<
  typename T1,typename Arg11,...,typename Arg15,
  typename T2
>
bool operator OP(const flyweight<T1,Arg11,...,Arg15>& x,const T2& y);

template<
  typename T1,
  typename T2,typename Arg21,...,typename Arg25
>
bool operator OP(const T1& x,const flyweight<T2,Arg21,...,Arg25>& y);

// specialized algorithms:

template<typename T,typename Arg1,...,typename Arg5>
inline void swap(
  flyweight<T,Arg1,...,Arg5>& x,flyweight<T,Arg1,...,Arg5>& y) noexcept;

template<
  typename ElemType,typename Traits, 
  typename T,typename Arg1,...,typename Arg5
>
inline std::basic_ostream<ElemType,Traits>& operator<<(
  std::basic_ostream<ElemType,Traits>& out,
  const flyweight<T,Arg1,...,Arg5>& x);

template<
  typename ElemType,typename Traits, 
  typename T,typename Arg1,...,typename Arg5
>
inline std::basic_istream<ElemType,Traits>& operator>>(
  std::basic_istream<ElemType,Traits>& in,
  flyweight<T,Arg1,...,Arg5>& x);

} // namespace boost::flyweights

using flyweights::flyweight;

} // namespace boost

// hash support:

namespace std{

template<class T> struct hash;
template<typename T,typename Arg1,...,typename Arg5>
struct hash<boost::flyweight<T,Arg1,...,Arg5> >;

} // namespace std 

namespace boost{
namespace flyweights{

template<typename T,typename Arg1,...,typename Arg5>
inline std::size_t hash_value(const flyweight<T,Arg1,...,Arg5>& x) noexcept;

} // namespace boost::flyweights
} // namespace boost

flyweight_fwd.hpp 前向声明类模板 flyweight 及其相关的全局函数和类模板特例。

头文件 "boost/flyweight/flyweight.hpp" 概要

类模板 flyweight

flyweight<...> 类型的对象提供对 flyweight<...>::value_type 类型不可变值的访问，与使用普通 value_type 对象相比，具有以下优点：

• 具有等效值的轻量级对象共享相同的表示（关联的 value_type 对象）。
• 轻量级对象的大小通常是一个指针的大小，通常小于 sizeof(value_type)。

flyweight 根据某些方面进行参数化：

• 类型 key_value 和 value_type（可能相等），其中 key_type 用作查找和构造 value_type 对象内部共享实例的键类型。
• 一个可选的 标签 类型，用于在语法上区分其他方面相同的实例化。
• 用于存储和检索共享值对象的 工厂类。
• 用于实例化轻量级工厂和互斥对象（两者对于 flyweight 类模板的每个特例都是唯一的）的 持有者 类型。
• 一个 锁定策略，用于确定对共享资源的内部访问的同步机制。
• 一个 跟踪策略，用于控制在销毁所有关联的轻量级对象时如何处理值。

• flyweight 的每个实例都内部拥有一个唯一的工厂对象和一个唯一的同步 互斥 对象，这两个对象都是通过使用关联的持有者类型创建的。
• 轻量级工厂存储未公开类型 Entry 的元素，该元素可以隐式转换为 const key_type&，并且还存储 value_type 的子对象。每个轻量级对象都与工厂中存储的某个 Entry 的 value_type 子对象关联。
• 关联的互斥对象用于保护对内部轻量级工厂的插入和删除函数的所有调用。
• 每个轻量级对象内部存储某个未公开类型 Handle 的值。Handle 和上面提到的 Entry 类型是从对关联跟踪策略的调用中获得的，其方式如该概念所述。

#include <initializer_list>

template<
  typename T,
  typename Arg1,typename Arg2,typename Arg3,typename Arg4,typename Arg5
>
class flyweight
{
public:
  typedef dependent on T key_type;
  typedef dependent on T value_type;

  // static data initialization:

  static bool init();
  class initializer{public:initializer();};
    
  // construct/copy/destroy:
  
  flyweight();

  template<typename... Args>
  explicit flyweight(Args&&... args);

  template<typename V>
  flyweight(std::initializer_list<V> list);

  flyweight(const flyweight& x) noexcept;
  flyweight(flyweight& x) noexcept;
  flyweight(const flyweight&& x) noexcept;
  flyweight(flyweight&& x) noexcept;
 
  explicit flyweight(const value_type& x);
  explicit flyweight(value_type& x);
  explicit flyweight(const value_type&& x);
  explicit flyweight(value_type&& x);

  template<typename V>
  flyweight& operator=(std::initializer_list<V> list);

  flyweight& operator=(const flyweight& x) noexcept;  

  flyweight& operator=(const value_type& x);
  flyweight& operator=(value_type&& x);

  // convertibility to underlying type:

  const key_type&   get_key() const noexcept(see below);
  const value_type& get() const noexcept;
  const value_type& operator*() const noexcept;
  operator const    value_type&() const noexcept;  
  const value_type* operator->() const noexcept;

  // modifiers:

  void swap(flyweight& x) noexcept;
};

实例化类型

T 可以是：

• 任意类型；
• key_value<Key,Value[,KeyFromValue]> 形式的类型。

如果提供，类型 Arg1、……、Arg5 必须是以下任何一种，顺序无关紧要：

• 一个 标签；
• 一个 工厂说明符；
• 一个 持有者说明符；
• 一个 锁定策略；
• 一个 跟踪策略。

• 无标签；
• hashed_factory<>,
• static_holder,
• simple_locking,
• refcounted 跟踪策略。

静态数据初始化

给定 flyweight 实例化的内部静态数据（工厂实例等）在程序的动态初始化阶段构造，并且始终在第一次程序范围使用已实例化的类之前构造。当需要更多控制构造时机时，可以使用以下实用程序。

效果：执行此函数后，保证已构造与 flyweight 实例关联的静态数据。
注意：此函数的并发执行不是线程安全的。

效果：执行 init()。

构造函数、复制和赋值

效果：如果 flyweight 是键值，则构造值为 value_type(key_type()) 的 flyweight 对象；否则构造值为 value_type() 的对象。

效果：如果 flyweight 是键值，则构造值为 value_type(key_type(std::forward<Args>(args)...)) 的 flyweight 对象；否则构造值为 value_type(std::forward<Args>(args)...) 的对象。
注意：在没有可变参数模板支持的编译器中，实现会用多个重载来代替此构造函数，这些重载最多接受用户可全局 配置 的最大数量的 const/非 const 左值/右值引用参数组合。

效果：如果 flyweight 是键值，则构造值为 value_type(key_type(list)) 的 flyweight 对象；否则构造值为 value_type(list) 的对象。
注意：除非 key_type 可以从 std::initializer_list<V'> 构造，否则此成员函数模板的特定 std::initializer_list<V'> 的特例不可用。

效果：构造与 x 相同值的 flyweight 对象。

要求：value_type 可以从参数类型构造。如果 flyweight 是键值，则必须已将 键提取器 KeyFromValue 作为 key_value<> 结构的一部分提供。
效果：构造与 x 的副本关联的 flyweight，或者构造从与 x 关联的键等效的键构造的 value_type。对于非键值轻量级对象，x 是其自身的键；对于键值轻量级对象，键是通过使用 KeyFromValue 类型对象提取的。

效果：*this=flyweight(list)。
返回：*this。
注意：除非 key_type 可以从 std::initializer_list<V'> 构造，否则此成员函数模板的特定 std::initializer_list<V'> 的特例不可用。

效果：将 flyweight 对象与 x 相同的值关联。
返回：*this。

效果：*this=flyweight(x)（第一个重载），*this=flyweight(std::move(x))（第二个重载）。
返回：*this。

转换为底层类型

返回：用于构造与 flyweight 对象关联的 value_type 的键的副本。
注意：如果 flyweight 不是键值，则为 noexcept；否则，如果未提供 KeyFromValue，或 noexcept(std::declval<KeyFromValue>()(std::declval<const value_type&>()))。

返回：与 flyweight 对象关联的值。

返回：与 flyweight 对象关联的值的地址。

修改器

效果：交换每个轻量级对象与 value_type 的关联。不会交换 key_type 或 value_type 对象。

比较运算符

返回值：如果x和y类型相同，当且仅当它们关联到相同的值时返回true；如果x和y类型不同，则返回x.get()==y.get()。
注意：如果x和y类型相同，则为noexcept。

返回值：x.get()==y。

返回值：x==y.get()。

返回值：x.get()<y.get()。

返回值：x.get()<y。

返回值：x<y.get()。

(OP 可以是 !=, >, >=, <= 之一)。

返回值：true 当且仅当

!(x==y) (OP 为 !=),
  y< x  (OP 为 > ),
!(x< y) (OP 为 >=),
!(y< x) (OP 为 <=).

注意：如果OP 为 != 且 x 和 y 类型相同，则为 noexcept。

专用算法

效果：x.swap(y)。

效果：out<<x.get()。
返回值：out。

需求：如果flyweight是键值对，value_type必须是可复制构造的，并且必须在key_value<>构造中提供键提取器 KeyFromValue。
效果：从in读取value_type类型的对象并将其赋值给x。
返回值：in。

哈希支持

支持使用std::hash和boost::hash对flyweight进行哈希。在这两种情况下，计算都不涉及对关联的value_type对象本身进行哈希；因此，value_type是否可哈希并不重要。对于同一个flyweight对象，std::hash和boost::hash给出的结果通常不同。
注意：可以禁用哈希支持，以解决与用户已定义此功能的代码冲突。

此模板特化满足[unord.hash]中类模板std::hash的要求。其函数调用运算符为noexcept。

返回值：x的哈希值，供Boost.ContainerHash使用。

配置宏

在不支持可变参数模板的编译器中，全局定义此宏以设置flyweight 转发构造函数接受的最大参数数量，默认为5。

如果已定义，则不提供哈希支持。这对于处理用户已定义通用flyweight哈希的遗留代码很有用。

头文件 "boost/flyweight/serialize.hpp" 概要

serialize.hpp包含flyweight与Boost.Serialization互操作所需的全部功能。

序列化

可以使用Boost.Serialization存档和检索flyweight。支持常规存档和XML存档。序列化以高效的方式完成，以便保存等效的flyweight只会将它们共有的key_type值存储一次，而不管key_type是否由Boost.Serialization跟踪。

需求：key_type是可序列化的（XML可序列化的）。
效果：在此操作或先前保存具有相同键的flyweight对象的操作中，将值k=x.get_key()保存到ar中。
异常安全：相对于x而言是强大的。如果抛出异常，ar可能处于不一致状态。

需求：key_type是可序列化的（XML可序列化的）。
效果：x'关联到从与k'（上面定义的值k的已恢复副本）等效的键构造的值。
异常安全：相对于x'而言是强大的。如果抛出异常，ar可能处于不一致状态。

Boost.Flyweight 参考

Boost.Flyweight 参考

键值轻量级对象

2024年9月28日修订

© 版权所有 2006-2024 Joaquín M López Muñoz。根据Boost软件许可证版本1.0分发。（参见随附文件 LICENSE_1_0.txt或复制自 https://boost.ac.cn/LICENSE_1_0.txt）