Boost.Flyweight flyweight 参考

Boost.Flyweight 参考

Boost.Flyweight 参考

键值 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 对象相比，具有以下优势

• 具有等效值的 Flyweight 对象共享相同的表示形式（关联的 value_type 对象）。
• flyweight 的大小通常是指针的大小，这通常小于 sizeof(value_type)。

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

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

• flyweight 的每个实例化在内部都拥有一个唯一的工厂对象和一个唯一的同步 互斥锁 对象，这两者都是通过使用关联的持有者类型创建的。
• flyweight 工厂存储未公开类型 Entry 的元素，该元素隐式可转换为 const key_type&，并且还存储 value_type 的子对象。每个 flyweight 对象都与工厂中存储的某些 Entry 的 value_type 子对象关联。
• 关联的互斥锁对象用于保护对内部 flyweight 工厂的插入和删除函数的所有调用。
• 每个 flyweight 对象在内部存储一些未公开类型 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 是键值 flyweight，则构造一个值为 value_type(key_type()) 的 flyweight 对象；否则构造一个值为 value_type() 的对象。

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

效果： 如果 flyweight 是键值 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 是键值 flyweight，则必须已提供 Key Extractor KeyFromValue 作为 key_value<> 构造的一部分。
效果： 构造一个与 x 的副本关联的 flyweight，或与从等效于与 x 关联的键构造的 value_type 关联的 flyweight。对于非键值 flyweight，x 本身就是其键；对于键值 flyweight，键通过使用 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 不是键值 flyweight，或者未提供 KeyFromValue，或者 noexcept(std::declval<KeyFromValue>()(std::declval<const value_type&>()))，则为 noexcept。

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

返回： 与 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 是键值 flyweight，则 value_type 是 CopyConstructible，并且必须已提供 Key Extractor KeyFromValue 作为 key_value<> 构造的一部分。
效果： 从 in 读取 value_type 类型的对象，并将其赋值给 x。
返回： in。

哈希支持

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

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

返回： 用于 Boost.ContainerHash 的 x 的哈希值。

配置宏

在没有可变参数模板支持的编译器中，全局定义此宏以设置 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 可序列化的）。
效果： 值 k=x.get_key() 作为此操作的一部分或先前保存具有相同键的 flyweight 对象的操作的一部分保存到 ar 中。
异常安全性： 对于 x 具有强异常安全性。如果抛出异常，ar 可能处于不一致状态。

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

Boost.Flyweight 参考

Boost.Flyweight 参考

键值 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 复制）