上一版本地址：
http://tieba.baidu.com/p/1043526998 。

项目维护用地址：http://code.google.com/p/yslib。

b301r13

@1.4.1 字符同态(homomorphism) ：
关于同态(homomorphism) ，参见基础数学。
设非空有限集 X 、 Y 和 E 满足：
E ⊂ X ，
X ∩ Y = Ø ；
设 x1 ∈ E ， x2 ∈ E ；
设存在二元高阶函数 f : E × E → X 和 g : Y × Y → Y 。
则可存在同态 h : X → Y 满足不变式 h(f(x1, x2)) = g(h(x1), h(x2)) 。
这里编译时确定的 X 和 Y 中的元素可以表示编码、字符集或区域(locale) 等字符相关的实体。
生成函数 f 和过滤函数 g 是在这些集合
上的高阶转换函数，用于取得这些映射。
CHRLib 的实现抽象 f 、 g 和 h ，表达它们的一些典型具体实例（如接受迭代器的字符序列转换），并提供便于用户引入新的实例的接口。
@1.4.1.1 典型抽象实例：
设存在非空的编码集 E 、转换规则集 C 和特征集 Y ， X = C ∪ E ， x1 ∈ E ， x2 ∈ E ；
高阶函数 f 是编码转换选择器， c = f(x1, x2) 是转换 x1 编码到 x2 编码的转换函数（接受字符序列作为参数），即 c ∈ C ；
高阶函数 g 是一个特征选择器，接受转换函数实现中对于指定的 x1 和 x2 所需的特征 h(x1) 和 h(x2) 分别作为参数，结果 y = g(h(x1), h(x2)) 是一个能表达适用于 x1 至 x2 转换特征的公共实现 y ∈ Y ；
则高阶函数 h 分别用于提取 x1 和 x2 中转换函数所需的特征，
此时不变式两端都为 y ，表示编码转换操作和特征选择操作的实现之间共有的特征。
用户指定 E 和 Y ，可通过库提供的原型设施适当构造 g 、 h 、f 和 C 并通过库设施得到对应的 c 。在 f 上应用 x1 和 x2 得到所需要的转换函数。
@1.4.1.2 关于字符编码转换相关的一个具体实例：
设编码集 E = {GBK, UTF-8} ，
原型集 P1 = {UTF-16LE, UTF-32} ，原型集 P2 = {zh-CN, zh-TW, zh-HK, zh-hans, en-US} ，
特征集 Y1 ⊂ {y | y : E × E → P1} 表示 E 中的编码转换过程中可使用 P1 作为中间代码，特征集 Y2 ⊂ {y | y : E → P2} 表示 E 中的编码可适用于 PC1 中的区域，
库原型设施 ph 、 pg 、 pf 和用户提供的编码解释器 e 、规则解释器 r ；
则可有 h = ph(e(E), r((Y1, PC1), (Y2, PC2))) ， g = pg(h) ， F = pf(g) ，
其中 f ∈ F 表示任意满足 Y1 和 Y2 约束的 E 中任意元素 x1 到 x2 的编码转换选择器， c = f(x1, x2) 是具体转换函数。


b309 d11
label line wrap

b321
之前优化消息队列实现和主循环空消息时Idle调用，FPS(release)一星期才搞到13000；
优化输入分发，搞到14000+；
结果Paint消息处理改成同步直接窜到28000，早知道直接搞这个了，囧……
这样按比例计算1GHz的U，空输入状态时每消息处理时间略小于3μs，差强人意，不知道还有多少优化余地。


using ystdex::void_ref;
using ystdex::any_holder;
using ystdex::value_holder;
using ystdex::any;
using ystdex::iterator_operations;
class any_iterator_holder : public any_holder
{
public:
virtual void_ref
operator*() const = 0;
virtual void
operator++() = 0;
};
class any_input_iterator_holder : public any_iterator_holder
{
public:
virtual bool
operator==(const any_input_iterator_holder&) const = 0;
};
template<typename _type>
class iterator_holder : public any_iterator_holder
{
protected:
typedef value_holder<_type> impl_type;
impl_type obj;
public:
iterator_holder(const _type& i)
: obj(i)
{}
iterator_holder(_type&& i) ynoexcept(ynoexcept(impl_type(std::move(i))))
: obj(std::move(i))
{}
void_ref
operator*() const override
{
yassume(!ystdex::is_undereferencable(get_obj()));
return *get_obj();


}
void
operator++() override
{
++get_obj();
}
iterator_holder*
clone() const override
{
return new iterator_holder(get_obj());
}
void*
get() const override
{
return obj.impl_type::get();
}
private:
_type&
get_obj() const
{
yassume(iterator_holder::get());
return *static_cast<_type*>(iterator_holder::get());
}
public:
const std::type_info&
type() const ynothrow override
{
return typeid(_type);
}
};
template<typename _type>
class input_iterator_holder : public any_input_iterator_holder
{
protected:
typedef iterator_holder<_type> impl_type;
impl_type obj;
public:
input_iterator_holder(const _type& i)
: obj(i)
{}
input_iterator_holder(_type&& i)
ynoexcept(ynoexcept(impl_type(std::move(i))))
: iterator_holder<_type>(std::move(i))
{}
void_ref
operator*() const override


{
return obj.impl_type::operator*();
}
void
operator++() override
{
return obj.impl_type::operator++();
}
bool
operator==(const any_input_iterator_holder& h) const override
{
if(h.type() != typeid(_type))
return true;
yassume(h.get());
return get_obj() == *static_cast<_type*>(h.get());
}
input_iterator_holder*
clone() const override
{
return new input_iterator_holder(get_obj());
}
void*
get() const override
{
return obj.impl_type::get();
}
private:
_type&
get_obj() const
{
yassume(input_iterator_holder::get());
return *static_cast<_type*>(input_iterator_holder::get());
}
public:
const std::type_info&
type() const ynothrow override
{
return typeid(_type);


}
};
template<typename _type, typename _tPointer, typename _tReference>
class any_input_iterator : public std::iterator<
std::input_iterator_tag, _type, std::ptrdiff_t, _tPointer, _tReference>
{
public:
typedef std::iterator<std::input_iterator_tag, _type,
std::ptrdiff_t, _tPointer, _tReference> iterator_type;
typedef _type value_type;
typedef _tPointer pointer;
typedef _tPointer reference;
private:
mutable any obj;
public:
any_input_iterator() = delete;
template<typename _tIterator>
explicit
any_input_iterator(_tIterator&& i)
: obj(new input_iterator_holder<typename
std::remove_reference<_tIterator>::type>(i), nullptr)
{}
any_input_iterator(const any_input_iterator&) = delete;
reference
operator*() const
{
return *get_holder();
}
pointer
operator->() const
{
return &**this;
}
any_input_iterator&
operator++()


{
++get_holder();
return *this;
}
any_input_iterator_holder&
get_holder() const
{
yassume(obj.get_holder());
return static_cast<any_input_iterator_holder&>(*obj.get_holder());
}
};
template<typename _type, typename _tPointer, typename _tReference>
inline bool
operator==(const any_input_iterator<_type, _tPointer, _tReference>& x,
const any_input_iterator<_type, _tPointer, _tReference>& y)
{
yconstraint(x.get_holder().type() == y.get_holder().type());
return x.get_holder() == y.get_holder();
}
template<typename _type, typename _tPointer, typename _tReference>
inline bool
operator!=(const any_input_iterator<_type, _tPointer, _tReference>& x,
const any_input_iterator<_type, _tPointer, _tReference>& y)
{
return !(x == y);
}
typedef ::any_input_iterator<void_ref, void*, void_ref>
input_monomorphic_iterator;


喵的panel绘制非缓冲透明部件时若存在扩大无效化区域就会污染到下层没缓冲的背景……偏偏不过一遍就不知道事先要补上多大地方的背景，鸡和蛋了……先坑。

多交叉编译了67次才搞清楚一个bad_alloc……亏我还趁早改异常类型了……

OK.
Hello world看来可以简化了。