factory.registerClass("A");

 一眼可以望穿的代码，实在没有什么可以说的。噢，补充一下。在Poco中的Singleton模型里并没有使用DCLP（Double Checked Locking）模式。什么是DCLP。可以参考文章Double Checked Locking 模式。

      其类图如下:

POCO C++库学习和分析 -- 进程

 Poco::Foundation库中涉及进程的内容主要包括了4个主题，分别是进程(Process)、进程间同步（inter-processsynchronization）、管道（Pipes）、共享内存（Shared Memory）。我们都知道管道、共享内存、网络通讯是进程间数据交互的3种基本方式。由于网络通讯足够复杂，在Poco的结构划分里被单独分成了一个库Net，Foundation库中并没有涉及。下面一一介绍：

1. 进程

       关于中的进程其实没有什么可说的，不管是其内部实现还是外部使用都非常的简单。内部实现上只不过是不同操作系统进程API的封装，下面是它的类图：

 在Poco中进程类的所有成员函数都是静态函数。主要的功能函数覆盖3个方面：

     1. 创建新进程

     2. 销毁其他进程

     3. 获取当前进程信息

      值得注意的是，在Poco中进程创建时，可以对进程的I/O进程重定向。其函数如下：

ProcessHandle Process::launch( conststd::string& path, const std::vector& args, Pipe*inPipe, Pipe* outPipe, Pipe* errPipe)

2.  进程间同步

       Poco库中提供了Poco::NamedMutex和Poco::NamedEvent类用于进程间的同步。同线程间同步的类Mutex，Event相比，进程间同步都是命名的，这毫无疑问是因为操作系统的底层函数的要求。

       其类图如下：

3. 管道

       我们都知道管道是一个单向的通讯通道，或者用来读或者用来写。如果两个进程间要实现双向的通讯，必须在进程之间创建两个管道。Poco库中也封装了管道方便进程通讯，但Poco库中对于管道的读写，却不是通过管道的本身，而是通过Poco::PipeOutputStream和Poco::PipeInputStream 两个类。这样的话，便可以实现和标准库流操作的无缝结合。

       下面是一个例子来说明这几者的关系：

#include"Poco/Process.h"

#include"Poco/PipeStream.h"

#include"Poco/StreamCopier.h"

#include

using Poco::Process;

using Poco::ProcessHandle;

int main(int argc, char** argv)

{

              std::string cmd("/bin/ps");

              std::vector args;

              args.push_back("-ax");

              Poco::Pipe outPipe;

              ProcessHandle ph = Process::launch(cmd, args, 0,&outPipe, 0);

              Poco::PipeInputStream istr(outPipe);

              std::ofstream ostr("processes.txt");

              Poco::StreamCopier::copyStream(istr, ostr);

              return 0;

}

管道的类图如下：

4. 共享内存

       在Poco库中，Poco::SharedMemory类用于实现共享内存功能。它支持两种创建方式：

       1.从确定大小的内存区域

       2. 从文件（通过把文件映射入共享内存区域）

       而在接口上，Poco::SharedMemory只外露了两个接口：

char* begin() const;

char* end() const;

 begin（）函数返回共享内存的起点，end（）函数则返回其终点。下面是它的类图和两个使用例子，并不复杂：

例子一：

// Map a file into memory

#include"Poco/SharedMemory.h"

#include"Poco/File.h"

using Poco::SharedMemory;

using Poco::File;

int main(int argc, char**argv)

{

              File f("MapIntoMemory.dat");

              SharedMemory mem(f, SharedMemory::AM_READ); //read-only access

              for (char* ptr = mem.begin(); ptr != mem.end(); ++ptr)

              {

                            // …

              }

              return 0;

}

例子二：

// Share a memory region of1024 bytes

#include"Poco/SharedMemory.h"

using Poco::SharedMemory;

int main(int argc, char**argv)

{

              SharedMemory mem("MySharedMemory", 1024,

                            SharedMemory::AM_READ |SharedMemory::AM_WRITE);

              for (char* ptr = mem.begin(); ptr != mem.end(); ++ptr)

              {

                            *ptr = 0;

              }

              return 0;

}

POCO C++库学习和分析 -- 通知和事件（一）

POCO C++库学习和分析 -- 通知和事件 （一）

1. 信息交流的方法

        在讨论Poco中事件与通知之前，先来聊一聊信息交流的方法，这样或许有助于理解接下去的讨论。我们都知道数据之间存在关系。在数据库模型里，关系被分为一对一，一对多，多对多。在用计算机去解决数据关系的时候，多对多关系往往被分解成为数个一对多，而一对多的关系最终被分解成为数个一对一关系。
       如果用关系的观点去看消息流动，消息存在一个或多个发起者，即消息源Source；消息也存在一个或多个接收者，即目标对象Target；同时消息Message本身具有内容，即多种消息。简化成为最终的一对一模型，来描述消息的，那么这个模型里的三个要素就是，Source，Message，Target。

       把这个模型放到C++语言中，Source，Message，Target分别被抽象成为三个类。那么消息传送的方式可以被写成如下两种方式：

1.1 放置模型于编程语言

       从消息源的角度来考虑问题，整个消息发送的流程是：
       a) 目标向消息源注册， Source.Register(Target)
       函数实现大致是这样的

[cpp] view plaincopy

1. Source.Register(Target)  

2. {  

3.      source.vec.add(Target);  

4. }  

       b) 消息产生
       Source create a msg
       c) 消息发送，Soucre.Send(Msg)
       上面这个函数大致如下:

[cpp] view plaincopy

1. Soucre.Send(Msg)  

2. {  

3.     Target.Receive(Msg);  

4. }  

       Target.Receive(Msg)的函数实现大致是这样的,

[cpp] view plaincopy

1. Target.Receive(Msg)  

2. {  

3.     switch(Msg)  

4.     {  

5.        case Msg1:  

6.          doing something;  

7.        case Msg2:  

8.          doing something;  

9.        default:  

10.          doing something;  

11.     }  

12. }  

       这种方式的调用可以说是最常见能够想到的方法了。最早写C代码的时候，就开始使用了，到C++时代也是。

       换个角度，在C++时代一切都是对象，从消息的角度来考虑这个问题呢，于是整个消息发送流程变成为：
       a) 目标向消息注册， Msg.Register(Target);
       Msg.Register(Target)函数实现大致是这样的

[cpp] view plaincopy

1. Msg.Register(Target)  

2.   

3.     Msg.vec.add(Target);  

       b) 消息产生
       a msg create by some one source 
       c) 消息发送，Msg.Send(Source)
       Msg.Send(Source)函数实现大致是这样的,

[cpp] view plaincopy

1. Msg.Send(Source)  

2. {  

3.     switch(Source)  

4.     {  

5.        case Source1:  

6.          doing something;  

7.        case Source2:  

8.          doing something;  

9.        default:  

10.          doing something;  

11.     }  

12. }  

       上面就是Poco中通知与事件的大致思路。其中通知是站在消息源的角度来考虑问题，而事件是站在消息的角度来考虑问题。插一句话，Poco中的事件和代理来自于C#。也就是说，分析Poco中的事件，其实是在解释C#的代理和事件的实现。

1.2 放置模型于多线程环境

       让我们抛开语言吧，把消息传递的过程放到多线程当中去。用多线程干吗？消息的产生就是为了最终的处理，假如消息处理很耗时间怎么办？
       没办法，兜里没银子。那句话怎么说来着，高富帅猛升硬件，穷挫矮死搞算法。毕竟大家不全是铁道部，是不？于是乎把消息的产生和处理放在两个线程中不是挺好的一个主意吗，这样毫无疑问消息处理的效率得到了提升。这也就是生产者和消费者模式。
       如果从这个角度考虑的问题的话，那么我们得到了消息传递的另外一种划分。同步处理消息和异步处理消息。

       于是我们可以把消息的传递过程分为下面4种：

         
                    通知    |    事件
                               |
       同步    (支持)  |  (支持)  
             ———————————
       异步    (支持)  |  (支持)  
                              |

       下面的章节我们将对Poco中消息和事件一一进行分析。

（版权所有，转载时请注明作者和出处  http://blog.csdn.net/arau_sh/article/details/8664372）

 POCO C++库学习和分析 -- 通知和事件 ( 二 )

2. 通知和事件的总览

2.1 相关类信息

        下面是Poco库和通知、事件相关的类
        1)  同步通知实现：类Notification和NotificationCenter
        2)  异步通知实现：类Notification和NotificationQueue
        3)  事件 Events

2.2 概述

        Poco文档上对于通知和事件的区别做了如下描述：
        1)  通知和事件是Poco库中支持的两种消息通知机制，目的是为了在源对象(source)发生某事件(something)时能够及时通知目的对象(target)
        2)  使用Poco中的通知，必须注意通知对象(target)也可称观察者(observer)将无法得知事件源的情况。Poco::NotificationCenter和Poco::NotificationQueue是消息传递的中间载体，用来对源(source)和目标(target)进行解耦。
        3) 如果对象(target)或者说观察者(observer)期望知道事件源的情况，或者想只从某一个确切的源接收事件，可以使用Poco::Event。Poco中的Event同时支持异步和同步消息。
        看了上面的文档，千万不要以为通知无法获取源对象的信息。事实上，通过对代码的改写，我们也可以使通知支持上述功能。只不过通知是基于消息源角度的设计，在设计时，就认为对于通知者，关注重点并不在消息源，而在消息类型。关于这一点，可以看前面一篇文章POCOC++库学习和分析 -- 通知和事件（一）。

        下图说明了同步消息时，消息发送的流程：

3. 同步通知

3.1 消息

        所有的通知类都继承自Poco::Notification，其定义如下：

[cpp] view plaincopy

1. class Notification: public RefCountedObject  

2. {  

3. public:  

4.     typedef AutoPtr Ptr;  

5.     Notification();  

6.     virtual std::string name() const;  

7.   

8.   

9. protected:  

10.     virtual ~Notification();  

11. };  

        从定义看，我们可以发现其从RefCountedObject类继承，也就是说其是一个引用计数对象。作为从RefCountedObject中继承的引用计数对象，毫无疑问在其在Poco中使用是和AutoPtr类配合的，完成堆对象的自动回收。关于AutoPtr的介绍，可以看前面的文章POCOC++库学习和分析 -- 内存管理(一)。

        使用时，我们可以从Notification继承，以便实现自己的通知，并且在通知类中可以放置我们想的任意数据，但是Poco中的Notification继承类不支持值语义操作，也就是说不支持拷贝构造函数(copy constructor)和赋值构造函数(assignment)。要注意的是这个限制并不是由于Notification继承类本身的限制导致的不支持，我们完全可以为其实现拷贝构造函数和赋值构造函数。这个限制是使用继承类的时候，为了实现动态对象的自动回收，消息的中介Poco::NotificationCenter和接收者Observer都使用了Poco::AutoPtr去传递和接收数据造成的。所以所有的Notification继承类对象都在堆上分配，运用时没有必要为其提供拷贝构造函数和赋值构造函数。

3.2 消息的发送者 source

        类NotificationCenter类扮演了一个消息源的角色。下面是它的定义：

[cpp] view plaincopy

1. class NotificationCenter  

2. {  

3. public:  

4.     NotificationCenter();  

5.     ~NotificationCenter();  

6.   

7.     void addObserver(const AbstractObserver& observer);  

8.     void removeObserver(const AbstractObserver& observer);  

9.   

10.     void postNotification(Notification::Ptr pNotification);  

11.   

12.     bool hasObservers() const;    

13.     std::size_t countObservers() const;  

14.           

15.     static NotificationCenter& defaultCenter();  

16.   

17. private:  

18.     typedef SharedPtr AbstractObserverPtr;  

19.     typedef std::vector ObserverList;  

20.   

21.     ObserverList  _observers;  

22.     mutable Mutex _mutex;  

23. };  

        从定义可以看出它是一个目标对象的集合std::vector>_observers。
        通过调用函数addObserver(constAbstractObserver& observer)，可以完成目标对象的注册过程。调用函数removeObserver()则可以完成反注册。而函数postNotification是一个消息传递的过程，其定义如下：

[cpp] view plaincopy

1. void NotificationCenter::postNotification(Notification::Ptr pNotification)  

2. {  

3.     poco_check_ptr (pNotification);  

4.   

5.   

6.     ScopedLockWithUnlock lock(_mutex);  

7.     ObserverList observersToNotify(_observers);  

8.     lock.unlock();  

9.     for (ObserverList::iterator it = observersToNotify.begin(); it !=   

10.   

11.   

12. observersToNotify.end(); ++it)  

13.     {  

14.         (*it)->notify(pNotification);  

15.     }  

16. }  

        从它的实现看，只是简单遍历_observers对象，并最终通过AbstractObserver->notify()把消息发送给通知对象。同时为了避免长时间占用_observers对象，在发送消息时，复制了一份。

        当使用者调用postNotification函数时，毫无疑问，消息被触发。

3.3 消息的接收者 target

        消息产生后，最终都要求被发送给合适的处理者。在C++中，处理者一定是一个对象，而处理即意味着行为，在C++中意味着类的成员函数，也就是说最终的处理要落实到类的对象实例的函数指针上。在Poco中，AbstractObserver可以理解成对象类的一个代理，它是一个纯虚类，定义了接收对象的接口。它的定义如下：

[cpp] view plaincopy

1. class AbstractObserver  

2. {  

3. public:  

4.     AbstractObserver();  

5.     AbstractObserver(const AbstractObserver& observer);  

6.     virtual ~AbstractObserver();  

7.       

8.     AbstractObserver& operator = (const AbstractObserver& observer);  

9.   

10.   

11.     virtual void notify(Notification* pNf) const = 0;  

12.     virtual bool equals(const AbstractObserver& observer) const = 0;  

13.     virtual bool accepts(Notification* pNf) const = 0;  

14.     virtual AbstractObserver* clone() const = 0;  

15.     virtual void disable() = 0;  

16. };  

        所有的接收者代理类都从类AbstractObserver继承，因为真实接收者的类类型未定，所以接受者代理类只能由模板技术去实现。这解决了处理时第一个问题。第二个问题是，不同的类处理函数可以不同。可以拥有一个，或多个参数，可以拥有或没有返回值。而编译器编译时，必须指定函数指针的类型。解决方法即把处理函数的类型固定下来。
        在Poco库的内部实现Observer类和NObserver类中，其定义分别是：

[cpp] view plaincopy

1. void (C::*Callback)(N*);  

2. void (C::*Callback)(const AutoPtr &);  

        函数调用时分别带了一个参数。这其实解决了所有的问题，因为一个参数可以是结构体，供使用传入传出所需的值。当然我们也可以从AbstractObserver继承实现自己的目标代理类，这样我们可以定义自己所需要的函数类型。让我们来看一下Observer定义，NObserver的分析类似。

[cpp] view plaincopy

1. template <class C, class N>  

2. class Observer: public AbstractObserver  

3. {  

4. public:  

5.     typedef void (C::*Callback)(N*);  

6.   

7.   

8.     Observer(C& object, Callback method):   

9.         _pObject(&object),   

10.         _method(method)  

11.     {  

12.     }  

13.       

14.     Observer(const Observer& observer):  

15.         AbstractObserver(observer),  

16.         _pObject(observer._pObject),   

17.         _method(observer._method)  

18.     {  

19.     }  

20.       

21.     ~Observer()  

22.     {  

23.     }  

24.       

25.     Observer& operator = (const Observer& observer)  

26.     {  

27.         if (&observer != this)  

28.         {  

29.             _pObject = observer._pObject;  

30.             _method  = observer._method;  

31.         }  

32.         return *this;  

33.     }  

34.       

35.     void notify(Notification* pNf) const  

36.     {  

37.         Poco::Mutex::ScopedLock lock(_mutex);  

38.   

39.   

40.         if (_pObject)  

41.         {  

42.             N* pCastNf = dynamic_cast(pNf);  

43.             if (pCastNf)  

44.             {  

45.                 pCastNf->duplicate();  

46.                 (_pObject->*_method)(pCastNf);  

47.             }  

48.         }  

49.     }  

50.       

51.     bool equals(const AbstractObserver& abstractObserver) const  

52.     {  

53.         const Observer* pObs = dynamic_cast<const Observer*>(&abstractObserver);  

54.         return pObs && pObs->_pObject == _pObject && pObs->_method == _method;  

55.     }  

56.   

57.   

58.     bool accepts(Notification* pNf) const  

59.     {  

60.         return dynamic_cast(pNf) != 0;  

61.     }  

62.       

63.     AbstractObserver* clone() const  

64.     {  

65.         return new Observer(*this);  

66.     }  

67.       

68.     void disable()  

69.     {  

70.         Poco::Mutex::ScopedLock lock(_mutex);  

71.           

72.         _pObject = 0;  

73.     }  

74.       

75. private:  

76.     Observer();  

77.   

78.   

79.     C*       _pObject;  

80.     Callback _method;  

81.     mutable Poco::Mutex _mutex;  

82. };  

        Observer中存在一个类实例对象的指针_pObject，以及对应函数入口地址_method。其处理函数为notify。这里注意两点：
        1. 使用了dynamic_cast转换，这意味着接受者处理的消息是向下继承的。如果一个对象订购了Poco::Notification，那么它将接受到所有继承自Poco::Notification的消息。

       2. 调用了pCastNf->duplicate(),增加了引用计数，这意味着处理者在处理函数中必须相应的去调用pCastNf->release(),去释放引用计数。在这里我倒是没有搞明白，为什么要调用duplicate()，在我看来不调用也完全可以。可能是为了照顾引用计数对象的语义，即引用计数对象的所有权发生了改变，从NotificationCenter对象独占转变成为了真实处理类对象和NotificationCenter对象共同拥有所有权。

3.4 一个使用例子

[cpp] view plaincopy

1. #include "Poco/NotificationCenter.h"  

2. #include "Poco/Notification.h"  

3. #include "Poco/Observer.h"  

4. #include "Poco/NObserver.h"  

5. #include "Poco/AutoPtr.h"  

6. #include   

7. using Poco::NotificationCenter;  

8. using Poco::Notification;  

9. using Poco::Observer;  

10. using Poco::NObserver;  

11. using Poco::AutoPtr;  

12. class BaseNotification: public Notification  

13. {  

14. };  

15. class SubNotification: public BaseNotification  

16. {  

17. };  

18.   

19.   

20. class Target  

21. {  

22. public:  

23.     void handleBase(BaseNotification* pNf)  

24.     {  

25.         std::cout << "handleBase: " << pNf->name() << std::endl;  

26.         pNf->release(); // we got ownership, so we must release  

27.     }  

28.     void handleSub(const AutoPtr& pNf)  

29.     {  

30.         std::cout << "handleSub: " << pNf->name() << std::endl;  

31.     }  

32. };  

33.   

34.   

35. int main(int argc, char** argv)  

36. {  

37.     NotificationCenter nc;  

38.     Target target;  

39.     nc.addObserver(  

40.         Observer(target, &Target::handleBase)  

41.         );  

42.     nc.addObserver(  

43.         NObserver(target, &Target::handleSub)  

44.         );  

45.     nc.postNotification(new BaseNotification);  

46.     nc.postNotification(new SubNotification);  

47.     nc.removeObserver(  

48.         Observer(target, &Target::handleBase)  

49.         );  

50.     nc.removeObserver(  

51.         NObserver(target, &Target::handleSub)  

52.         );  

53.     return 0;  

54. }  

3.5 最后给出同步通知的类图

POCO C++库学习和分析 -- 通知和事件 ( 二 )

2. 通知和事件的总览

2.1 相关类信息

        下面是Poco库和通知、事件相关的类
        1)  同步通知实现：类Notification和NotificationCenter
        2)  异步通知实现：类Notification和NotificationQueue
        3)  事件 Events

2.2 概述

        Poco文档上对于通知和事件的区别做了如下描述：
        1)  通知和事件是Poco库中支持的两种消息通知机制，目的是为了在源对象(source)发生某事件(something)时能够及时通知目的对象(target)
        2)  使用Poco中的通知，必须注意通知对象(target)也可称观察者(observer)将无法得知事件源的情况。Poco::NotificationCenter和Poco::NotificationQueue是消息传递的中间载体，用来对源(source)和目标(target)进行解耦。
        3) 如果对象(target)或者说观察者(observer)期望知道事件源的情况，或者想只从某一个确切的源接收事件，可以使用Poco::Event。Poco中的Event同时支持异步和同步消息。
        看了上面的文档，千万不要以为通知无法获取源对象的信息。事实上，通过对代码的改写，我们也可以使通知支持上述功能。只不过通知是基于消息源角度的设计，在设计时，就认为对于通知者，关注重点并不在消息源，而在消息类型。关于这一点，可以看前面一篇文章POCOC++库学习和分析 -- 通知和事件（一）。

        下图说明了同步消息时，消息发送的流程：

3. 同步通知

3.1 消息

        所有的通知类都继承自Poco::Notification，其定义如下：

[cpp] view plaincopy

1. class Notification: public RefCountedObject  

2. {  

3. public:  

4.     typedef AutoPtr Ptr;  

5.     Notification();  

6.     virtual std::string name() const;  

7.   

8.   

9. protected:  

10.     virtual ~Notification();  

11. };  

        从定义看，我们可以发现其从RefCountedObject类继承，也就是说其是一个引用计数对象。作为从RefCountedObject中继承的引用计数对象，毫无疑问在其在Poco中使用是和AutoPtr类配合的，完成堆对象的自动回收。关于AutoPtr的介绍，可以看前面的文章POCOC++库学习和分析 -- 内存管理(一)。

        使用时，我们可以从Notification继承，以便实现自己的通知，并且在通知类中可以放置我们想的任意数据，但是Poco中的Notification继承类不支持值语义操作，也就是说不支持拷贝构造函数(copy constructor)和赋值构造函数(assignment)。要注意的是这个限制并不是由于Notification继承类本身的限制导致的不支持，我们完全可以为其实现拷贝构造函数和赋值构造函数。这个限制是使用继承类的时候，为了实现动态对象的自动回收，消息的中介Poco::NotificationCenter和接收者Observer都使用了Poco::AutoPtr去传递和接收数据造成的。所以所有的Notification继承类对象都在堆上分配，运用时没有必要为其提供拷贝构造函数和赋值构造函数。

3.2 消息的发送者 source

        类NotificationCenter类扮演了一个消息源的角色。下面是它的定义：

[cpp] view plaincopy

1. class NotificationCenter  

2. {  

3. public:  

4.     NotificationCenter();  

5.     ~NotificationCenter();  

6.   

7.     void addObserver(const AbstractObserver& observer);  

8.     void removeObserver(const AbstractObserver& observer);  

9.   

10.     void postNotification(Notification::Ptr pNotification);  

11.   

12.     bool hasObservers() const;    

13.     std::size_t countObservers() const;  

14.           

15.     static NotificationCenter& defaultCenter();  

16.   

17. private:  

18.     typedef SharedPtr AbstractObserverPtr;  

19.     typedef std::vector ObserverList;  

20.   

21.     ObserverList  _observers;  

22.     mutable Mutex _mutex;  

23. };  

        从定义可以看出它是一个目标对象的集合std::vector>_observers。
        通过调用函数addObserver(constAbstractObserver& observer)，可以完成目标对象的注册过程。调用函数removeObserver()则可以完成反注册。而函数postNotification是一个消息传递的过程，其定义如下：

[cpp] view plaincopy

1. void NotificationCenter::postNotification(Notification::Ptr pNotification)  

2. {  

3.     poco_check_ptr (pNotification);  

4.   

5.   

6.     ScopedLockWithUnlock lock(_mutex);  

7.     ObserverList observersToNotify(_observers);  

8.     lock.unlock();  

9.     for (ObserverList::iterator it = observersToNotify.begin(); it !=   

10.   

11.   

12. observersToNotify.end(); ++it)  

13.     {  

14.         (*it)->notify(pNotification);  

15.     }  

16. }  

        从它的实现看，只是简单遍历_observers对象，并最终通过AbstractObserver->notify()把消息发送给通知对象。同时为了避免长时间占用_observers对象，在发送消息时，复制了一份。

        当使用者调用postNotification函数时，毫无疑问，消息被触发。

3.3 消息的接收者 target

        消息产生后，最终都要求被发送给合适的处理者。在C++中，处理者一定是一个对象，而处理即意味着行为，在C++中意味着类的成员函数，也就是说最终的处理要落实到类的对象实例的函数指针上。在Poco中，AbstractObserver可以理解成对象类的一个代理，它是一个纯虚类，定义了接收对象的接口。它的定义如下：

[cpp] view plaincopy

1. class AbstractObserver  

2. {  

3. public:  

4.     AbstractObserver();  

5.     AbstractObserver(const AbstractObserver& observer);  

6.     virtual ~AbstractObserver();  

7.       

8.     AbstractObserver& operator = (const AbstractObserver& observer);  

9.   

10.   

11.     virtual void notify(Notification* pNf) const = 0;  

12.     virtual bool equals(const AbstractObserver& observer) const = 0;  

13.     virtual bool accepts(Notification* pNf) const = 0;  

14.     virtual AbstractObserver* clone() const = 0;  

15.     virtual void disable() = 0;  

16. };  

        所有的接收者代理类都从类AbstractObserver继承，因为真实接收者的类类型未定，所以接受者代理类只能由模板技术去实现。这解决了处理时第一个问题。第二个问题是，不同的类处理函数可以不同。可以拥有一个，或多个参数，可以拥有或没有返回值。而编译器编译时，必须指定函数指针的类型。解决方法即把处理函数的类型固定下来。
        在Poco库的内部实现Observer类和NObserver类中，其定义分别是：

[cpp] view plaincopy

1. void (C::*Callback)(N*);  

2. void (C::*Callback)(const AutoPtr &);  

        函数调用时分别带了一个参数。这其实解决了所有的问题，因为一个参数可以是结构体，供使用传入传出所需的值。当然我们也可以从AbstractObserver继承实现自己的目标代理类，这样我们可以定义自己所需要的函数类型。让我们来看一下Observer定义，NObserver的分析类似。

[cpp] view plaincopy

1. template <class C, class N>  

2. class Observer: public AbstractObserver  

3. {  

4. public:  

5.     typedef void (C::*Callback)(N*);  

6.   

7.   

8.     Observer(C& object, Callback method):   

9.         _pObject(&object),   

10.         _method(method)  

11.     {  

12.     }  

13.       

14.     Observer(const Observer& observer):  

15.         AbstractObserver(observer),  

16.         _pObject(observer._pObject),   

17.         _method(observer._method)  

18.     {  

19.     }  

20.       

21.     ~Observer()  

22.     {  

23.     }  

24.       

25.     Observer& operator = (const Observer& observer)  

26.     {  

27.         if (&observer != this)  

28.         {  

29.             _pObject = observer._pObject;  

30.             _method  = observer._method;  

31.         }  

32.         return *this;  

33.     }  

34.       

35.     void notify(Notification* pNf) const  

36.     {  

37.         Poco::Mutex::ScopedLock lock(_mutex);  

38.   

39.   

40.         if (_pObject)  

41.         {  

42.             N* pCastNf = dynamic_cast(pNf);  

43.             if (pCastNf)  

44.             {  

45.                 pCastNf->duplicate();  

46.                 (_pObject->*_method)(pCastNf);  

47.             }  

48.         }  

49.     }  

50.       

51.     bool equals(const AbstractObserver& abstractObserver) const  

52.     {  

53.         const Observer* pObs = dynamic_cast<const Observer*>(&abstractObserver);  

54.         return pObs && pObs->_pObject == _pObject && pObs->_method == _method;  

55.     }  

56.   

57.   

58.     bool accepts(Notification* pNf) const  

59.     {  

60.         return dynamic_cast(pNf) != 0;  

61.     }  

62.       

63.     AbstractObserver* clone() const  

64.     {  

65.         return new Observer(*this);  

66.     }  

67.       

68.     void disable()  

69.     {  

70.         Poco::Mutex::ScopedLock lock(_mutex);  

71.           

72.         _pObject = 0;  

73.     }  

74.       

75. private:  

76.     Observer();  

77.   

78.   

79.     C*       _pObject;  

80.     Callback _method;  

81.     mutable Poco::Mutex _mutex;  

82. };  

        Observer中存在一个类实例对象的指针_pObject，以及对应函数入口地址_method。其处理函数为notify。这里注意两点：
        1. 使用了dynamic_cast转换，这意味着接受者处理的消息是向下继承的。如果一个对象订购了Poco::Notification，那么它将接受到所有继承自Poco::Notification的消息。

       2. 调用了pCastNf->duplicate(),增加了引用计数，这意味着处理者在处理函数中必须相应的去调用pCastNf->release(),去释放引用计数。在这里我倒是没有搞明白，为什么要调用duplicate()，在我看来不调用也完全可以。可能是为了照顾引用计数对象的语义，即引用计数对象的所有权发生了改变，从NotificationCenter对象独占转变成为了真实处理类对象和NotificationCenter对象共同拥有所有权。

3.4 一个使用例子

[cpp] view plaincopy

1. #include "Poco/NotificationCenter.h"  

2. #include "Poco/Notification.h"  

3. #include "Poco/Observer.h"  

4. #include "Poco/NObserver.h"  

5. #include "Poco/AutoPtr.h"  

6. #include   

7. using Poco::NotificationCenter;  

8. using Poco::Notification;  

9. using Poco::Observer;  

10. using Poco::NObserver;  

11. using Poco::AutoPtr;  

12. class BaseNotification: public Notification  

13. {  

14. };  

15. class SubNotification: public BaseNotification  

16. {  

17. };  

18.   

19.   

20. class Target  

21. {  

22. public:  

23.     void handleBase(BaseNotification* pNf)  

24.     {  

25.         std::cout << "handleBase: " << pNf->name() << std::endl;  

26.         pNf->release(); // we got ownership, so we must release  

27.     }  

28.     void handleSub(const AutoPtr& pNf)  

29.     {  

30.         std::cout << "handleSub: " << pNf->name() << std::endl;  

31.     }  

32. };  

33.   

34.   

35. int main(int argc, char** argv)  

36. {  

37.     NotificationCenter nc;  

38.     Target target;  

39.     nc.addObserver(  

40.         Observer(target, &Target::handleBase)  

41.         );  

42.     nc.addObserver(  

43.         NObserver(target, &Target::handleSub)  

44.         );  

45.     nc.postNotification(new BaseNotification);  

46.     nc.postNotification(new SubNotification);  

47.     nc.removeObserver(  

48.         Observer(target, &Target::handleBase)  

49.         );  

50.     nc.removeObserver(  

51.         NObserver(target, &Target::handleSub)  

52.         );  

53.     return 0;  

54. }  

3.5 最后给出同步通知的类图

 POCO C++库学习和分析 -- 通知和事件 （三）

4. 异步通知

4.1 NotificationQueue类

         Poco中的异步通知是通过NotificationQueue类来实现的，同它功能类似还有类PriorityNotificationQueue和TimedNotificationQueue。不同的是PriorityNotificationQueue类中对消息分了优先级，对优先级高的消息优先处理；而TimedNotificationQueue对消息给了时间戳，时间戳早的优先处理，而和其压入队列的时间无关。所以接下来我们主要关注NotificationQueue的实现。
        事实上NotificationQueue是个非常有趣的类。让我们来看一下它的头文件：

[cpp] view plaincopy

1. class Foundation_API NotificationQueue  

2.     /// A NotificationQueue object provides a way to implement asynchronous  

3.     /// notifications. This is especially useful for sending notifications  

4.     /// from one thread to another, for example from a background thread to   

5.     /// the main (user interface) thread.   

6.     ///   

7.     /// The NotificationQueue can also be used to distribute work from  

8.     /// a controlling thread to one or more worker threads. Each worker thread  

9.     /// repeatedly calls waitDequeueNotification() and processes the  

10.     /// returned notification. Special care must be taken when shutting  

11.     /// down a queue with worker threads waiting for notifications.  

12.     /// The recommended sequence to shut down and destroy the queue is to  

13.     ///   1. set a termination flag for every worker thread  

14.     ///   2. call the wakeUpAll() method  

15.     ///   3. join each worker thread  

16.     ///   4. destroy the notification queue.  

17. {  

18. public:  

19.     NotificationQueue();  

20.         /// Creates the NotificationQueue.  

21.   

22.     ~NotificationQueue();  

23.         /// Destroys the NotificationQueue.  

24.   

25.     void enqueueNotification(Notification::Ptr pNotification);  

26.         /// Enqueues the given notification by adding it to  

27.         /// the end of the queue (FIFO).  

28.         /// The queue takes ownership of the notification, thus  

29.         /// a call like  

30.         ///     notificationQueue.enqueueNotification(new MyNotification);  

31.         /// does not result in a memory leak.  

32.           

33.     void enqueueUrgentNotification(Notification::Ptr pNotification);  

34.         /// Enqueues the given notification by adding it to  

35.         /// the front of the queue (LIFO). The event therefore gets processed  

36.         /// before all other events already in the queue.  

37.         /// The queue takes ownership of the notification, thus  

38.         /// a call like  

39.         ///     notificationQueue.enqueueUrgentNotification(new MyNotification);  

40.         /// does not result in a memory leak.  

41.   

42.     Notification* dequeueNotification();  

43.         /// Dequeues the next pending notification.  

44.         /// Returns 0 (null) if no notification is available.  

45.         /// The caller gains ownership of the notification and  

46.         /// is expected to release it when done with it.  

47.         ///  

48.         /// It is highly recommended that the result is immediately  

49.         /// assigned to a Notification::Ptr, to avoid potential  

50.         /// memory management issues.  

51.   

52.     Notification* waitDequeueNotification();  

53.         /// Dequeues the next pending notification.  

54.         /// If no notification is available, waits for a notification  

55.         /// to be enqueued.   

56.         /// The caller gains ownership of the notification and  

57.         /// is expected to release it when done with it.  

58.         /// This method returns 0 (null) if wakeUpWaitingThreads()  

59.         /// has been called by another thread.  

60.         ///  

61.         /// It is highly recommended that the result is immediately  

62.         /// assigned to a Notification::Ptr, to avoid potential  

63.         /// memory management issues.  

64.   

65.     Notification* waitDequeueNotification(long milliseconds);  

66.         /// Dequeues the next pending notification.  

67.         /// If no notification is available, waits for a notification  

68.         /// to be enqueued up to the specified time.  

69.         /// Returns 0 (null) if no notification is available.  

70.         /// The caller gains ownership of the notification and  

71.         /// is expected to release it when done with it.  

72.         ///  

73.         /// It is highly recommended that the result is immediately  

74.         /// assigned to a Notification::Ptr, to avoid potential  

75.         /// memory management issues.  

76.   

77.     void dispatch(NotificationCenter& notificationCenter);  

78.         /// Dispatches all queued notifications to the given  

79.         /// notification center.  

80.   

81.     void wakeUpAll();  

82.         /// Wakes up all threads that wait for a notification.  

83.       

84.     bool empty() const;  

85.         /// Returns true iff the queue is empty.  

86.           

87.     int size() const;  

88.         /// Returns the number of notifications in the queue.  

89.   

90.     void clear();  

91.         /// Removes all notifications from the queue.  

92.           

93.     bool hasIdleThreads() const;      

94.         /// Returns true if the queue has at least one thread waiting   

95.         /// for a notification.  

96.           

97.     static NotificationQueue& defaultQueue();  

98.         /// Returns a reference to the default  

99.         /// NotificationQueue.  

100.   

101. protected:  

102.     Notification::Ptr dequeueOne();  

103.       

104. private:  

105.     typedef std::deque NfQueue;  

106.     struct WaitInfo  

107.     {  

108.         Notification::Ptr pNf;  

109.         Event             nfAvailable;  

110.     };  

111.     typedef std::deque WaitQueue;  

112.   

113.     NfQueue           _nfQueue;  

114.     WaitQueue         _waitQueue;  

115.     mutable FastMutex _mutex;  

116. };  

        从定义可以看到NotificationQueue类管理了两个deque容器。其中一个是WaitInfo对象的deque，另一个是Notification对象的deque。而WaitInfo一对一的对应了一个消息对象pNf和事件对象nfAvailable，毫无疑问Event对象是用来同步多线程的。让我们来看看它如何实现。
       NotificationQueue实现的巧妙之处就在于WaitInfo由消费者动态创建，消费者线程通过函数Notification* waitDequeueNotification()获取消息，其函数定义如下：

[cpp] view plaincopy

1. Notification* NotificationQueue::waitDequeueNotification()  

2. {  

3.     Notification::Ptr pNf;  

4.     WaitInfo* pWI = 0;  

5.     {  

6.         FastMutex::ScopedLock lock(_mutex);  

7.         pNf = dequeueOne();  

8.         if (pNf) return pNf.duplicate();  

9.         pWI = new WaitInfo;  

10.         _waitQueue.push_back(pWI);  

11.     }  

12.     pWI->nfAvailable.wait();  

13.     pNf = pWI->pNf;  

14.     delete pWI;  

15.     return pNf.duplicate();  

16. }  

17.   

18. Notification::Ptr NotificationQueue::dequeueOne()  

19. {  

20.     Notification::Ptr pNf;  

21.     if (!_nfQueue.empty())  

22.     {  

23.         pNf = _nfQueue.front();  

24.         _nfQueue.pop_front();  

25.     }  

26.     return pNf;  

27. }  

        消费者线程首先从Notification对象的deque中获取消息，如果消息获取不为空，则直接返回处理，如果消息为空，则创建一个新的WaitInfo对象，并压入WaitInfo对象的
deque。消费者线程开始等待，直到生产者通知有消息的存在，然后再从WaitInfo对象中取出消息，返回处理。当消费者线程能从Notification对象的deque中获取到消息时，说明消费者处理消息的速度要比生成者低；反之则说明消费者处理消息的速度要比生成者高。

        让我们再看一下生产者的调用函数voidNotificationQueue::enqueueNotification(Notification::Ptr pNotification)，其定义如下：

[cpp] view plaincopy

1. void NotificationQueue::enqueueNotification(Notification::Ptr pNotification)  

2. {  

3.     poco_check_ptr (pNotification);  

4.     FastMutex::ScopedLock lock(_mutex);  

5.     if (_waitQueue.empty())  

6.     {  

7.         _nfQueue.push_back(pNotification);  

8.     }  

9.     else  

10.     {  

11.         WaitInfo* pWI = _waitQueue.front();  

12.         _waitQueue.pop_front();  

13.         pWI->pNf = pNotification;  

14.         pWI->nfAvailable.set();  

15.     }     

16. }  

        生产者线程首先判断WaitInfo对象的deque是否为空，如果不为空，说明存在消费者线程等待，则从deque中获取一个WaitInfo对象，灌入Notification消息，释放信号量激活消费者线程；而如果为空，说明目前说有的消费者线程都在工作，则把消息暂时存入Notification对象的deque，等待消费者线程有空时处理。
        整个处理过程中对于_mutex对象的处理是非常小心的，_waitQueue不被使用则释放。OK，整个流程结束，消息源和目标被解耦。

4.2 一个异步通知的例子

[cpp] view plaincopy

1. #include "Poco/Notification.h"  

2. #include "Poco/NotificationQueue.h"  

3. #include "Poco/ThreadPool.h"  

4. #include "Poco/Runnable.h"  

5. #include "Poco/AutoPtr.h"  

6. using Poco::Notification;  

7. using Poco::NotificationQueue;  

8. using Poco::ThreadPool;  

9. using Poco::Runnable;  

10. using Poco::AutoPtr;  

11. class WorkNotification: public Notification  

12. {  

13. public:  

14.     WorkNotification(int data): _data(data) {}  

15.     int data() const  

16.     {  

17.         return _data;  

18.     }  

19. private:  

20.     int _data;  

21. };  

22.   

23.   

24. class Worker: public Runnable  

25. {  

26. public:  

27.     Worker(NotificationQueue& queue): _queue(queue) {}  

28.     void run()  

29.     {  

30.         AutoPtr pNf(_queue.waitDequeueNotification());  

31.         while (pNf)  

32.         {  

33.             WorkNotification* pWorkNf =  

34.                 dynamic_cast(pNf.get());  

35.             if (pWorkNf)  

36.             {  

37.                 // do some work  

38.             }  

39.             pNf = _queue.waitDequeueNotification();  

40.         }  

41.     }  

42. private:  

43.     NotificationQueue& _queue;  

44. };  

45.   

46.   

47. int main(int argc, char** argv)  

48. {  

49.     NotificationQueue queue;  

50.     Worker worker1(queue); // create worker threads  

51.     Worker worker2(queue);  

52.     ThreadPool::defaultPool().start(worker1); // start workers  

53.     ThreadPool::defaultPool().start(worker2);  

54.     // create some work  

55.     for (int i = 0; i < 100; ++i)  

56.     {  

57.         queue.enqueueNotification(new WorkNotification(i));  

58.     }  

59.     while (!queue.empty()) // wait until all work is done  

60.         Poco::Thread::sleep(100);  

61.     queue.wakeUpAll(); // tell workers they're done  

62.     ThreadPool::defaultPool().joinAll();  

63.     return 0;  

64. }  

4.3 异步通知的类图

        最后给出异步通知的类图:

POCO C++库学习和分析 -- 通知和事件 （四）

5. 事件

        Poco中的事件和代理概念来自于C#。对于事件的使用者，也就是调用方来说，用法非常的简单。

5.1 从例子说起

        首先让我们来看一个同步事件例子，然后再继续我们的讨论：

[cpp] view plaincopy

1. #include "Poco/BasicEvent.h"  

2. #include "Poco/Delegate.h"  

3. #include   

4.   

5. using Poco::BasicEvent;  

6. using Poco::Delegate;  

7.   

8. class Source  

9. {  

10. public:  

11.     BasicEvent<int> theEvent;  

12.     void fireEvent(int n)  

13.     {  

14.         theEvent(this, n);  

15.         // theEvent.notify(this, n); // alternative syntax  

16.     }  

17. };  

18.   

19. class Target  

20. {  

21. public:  

22.     void onEvent(const void* pSender, int& arg)  

23.     {  

24.         std::cout << "onEvent: " << arg << std::endl;  

25.     }  

26. };  

27.   

28. int main(int argc, char** argv)  

29. {  

30.     Source source;  

31.     Target target;  

32.     source.theEvent += Poco::delegate(&target, &Target::onEvent);  

33.     source.fireEvent(42);  

34.     source.theEvent -= Poco::delegate(&target, &Target::onEvent);  

35.   

36.     return 0;  

37. }  

        从上面的代码里，我们可以清晰的看到几个部分，数据源Source，事件BasicEvent，目标对象Target。

        其中source.theEvent += Poco::delegate(&target, &Target::onEvent)完成了，目标向数据源事件注册的过程。大家都知道在C++中，程序运行是落实到类的实例的，看一下消息传递的过程，Poco是如何解决这个问题。target是目标对象实例，Target::onEvent目标对象处理事件的函数入口地址。source.fireEvent(42)触发事件运行，其定义为:

[cpp] view plaincopy

1. void fireEvent(int n)  

2. {  

3.     theEvent(this, n);  

4.     // theEvent.notify(this, n); // alternative syntax  

5. }  

        theEvent(this,n)中存在两个参数，其中n为Target::onEvent(const void* pSender, int& arg)处理函数的参数，可理解为消息或者事件内容；this给出了触发源实例的信息。
ok。这样消息的传递流程出来了。消息源实例的地址，消息内容，目标实例地址，目标实例类的处理函数入口地址。使用者填入上述信息就可以传递消息了。相当简单。

        而对于事件的开发者，如何实现上述功能。这是另外一码事，用C++实现这么一个功能还是挺复杂的一件事。看一下使用语言的方式，想一下用到的C++技术：
        1. +=/-= 重载

[cpp] view plaincopy

1. source.theEvent += Poco::delegate(&target, &Target::onEvent);  

        2. 仿函式

[cpp] view plaincopy

1. theEvent(this, n);  

        3. 模板
        开发者是不应该限定使用者发送消息的类以及接受消息类的类型的，因此C++中能够完成此功能的技术只有模板了。关于模板编程还想聊上几句。STL的特点在于算法和数据结构的分离，这个其实也是泛型编程的特点。如果把使用者对于类的应用过程看做算法过程的话，就可以对这个过程进行泛型编程。同时应该注意的是，算法和数据结构是存在关联的，这是隐含在泛型编程中的，能够使用某种算法的数据结构一定是符合该种算法要求的。
        就拿Poco中事件的委托Delegate来说，目标对象处理事件的函数入口是存在某种假设的。Poco中假设入口函数必须是如下形式之一：

[cpp] view plaincopy

1. void (TObj::*NotifyMethod)(const void*, TArgs&);  

2. void (TObj::*NotifyMethod)(TArgs&);  

3. void (*NotifyMethod)(const void*, TArgs&);  

4. void (*NotifyMethod)(void*, TArgs&);  

5.2 事件的实现

        下面一张图是Poco中Event的类图：

        下面另一张图是Poco中Event流动的过程：

        从图上看实现事件的类被分成了几类：
        1) Delegate： 

            AbstractDelegate,Delegate,Expire,FunctionDelegate,AbstractPriorityDelegate,PriorityDelegate,FunctionPriorityDelegate：
        2) Strategy：
             NotificationStrategy，PriorityStrategy，DefaultStrategy，FIFOStrategy
        3) Event：
            AbstractEvent，PriorityEvent，FIFOEvent，BasicEvent

        我们取Delegate，DefaultStrategy，BasicEvent来分析，其他的只是在它们的基础上加了一些修饰，流程类似。

        Delegate类定义如下：

[cpp] view plaincopy

1. template <class TObj, class TArgs, bool withSender = true>   

2. class Delegate: public AbstractDelegate  

3. {  

4. public:  

5.     typedef void (TObj::*NotifyMethod)(const void*, TArgs&);  

6.   

7.     Delegate(TObj* obj, NotifyMethod method):  

8.         _receiverObject(obj),   

9.         _receiverMethod(method)  

10.     {  

11.     }  

12.   

13.     Delegate(const Delegate& delegate):  

14.         AbstractDelegate(delegate),  

15.         _receiverObject(delegate._receiverObject),  

16.         _receiverMethod(delegate._receiverMethod)  

17.     {  

18.     }  

19.   

20.     ~Delegate()  

21.     {  

22.     }  

23.       

24.     Delegate& operator = (const Delegate& delegate)  

25.     {  

26.         if (&delegate != this)  

27.         {  

28.             this->_receiverObject = delegate._receiverObject;  

29.             this->_receiverMethod = delegate._receiverMethod;  

30.         }  

31.         return *this;  

32.     }  

33.   

34.     bool notify(const void* sender, TArgs& arguments)  

35.     {  

36.         Mutex::ScopedLock lock(_mutex);  

37.         if (_receiverObject)  

38.         {  

39.             (_receiverObject->*_receiverMethod)(sender, arguments);  

40.             return true;  

41.         }  

42.         else return false;  

43.     }  

44.   

45.     bool equals(const AbstractDelegate& other) const  

46.     {  

47.         const Delegate* pOtherDelegate = reinterpret_cast<const Delegate*>(other.unwrap());  

48.         return pOtherDelegate && _receiverObject == pOtherDelegate->_receiverObject && _receiverMethod == pOtherDelegate->_receiverMethod;  

49.     }  

50.   

51.     AbstractDelegate* clone() const  

52.     {  

53.         return new Delegate(*this);  

54.     }  

55.       

56.     void disable()  

57.     {  

58.         Mutex::ScopedLock lock(_mutex);  

59.         _receiverObject = 0;  

60.     }  

61.   

62. protected:  

63.     TObj*        _receiverObject;  

64.     NotifyMethod _receiverMethod;  

65.     Mutex        _mutex;  

66.   

67.   

68. private:  

69.     Delegate();  

70. };  

        我们可以看到Delegate类中存储了目标类实例的指针_receiverObject，同时存储了目标类处理函数的入口地址_receiverMethod，当初始化Delegate实例时，参数被带进。
Delegate类中处理事件的函数为bool notify(const void* sender, TArgs&arguments)，这是一个虚函数. 如果去看它的实现的话，它最终调用了目标类处理函数

(_receiverObject->*_receiverMethod)(sender,arguments)。如果用简单的话来描述Delegate的作用，那就是目标类的代理。

        在Poco中对于Delegate提供了模板函数delegate，来隐藏Delegate对象的创建，其定义如下：

[cpp] view plaincopy

1. template <class TObj, class TArgs>  

2. static Delegate<TObj, TArgs, true> delegate(TObj* pObj, void (TObj::*NotifyMethod)(const void*, TArgs&))  

3. {  

4.     return Delegate<TObj, TArgs, true>(pObj, NotifyMethod);  

5. }  

        在来看DefaultStrategy类，其定义如下：

[cpp] view plaincopy

1. template <class TArgs, class TDelegate>   

2. class DefaultStrategy: public NotificationStrategy  

3.     /// Default notification strategy.  

4.     ///  

5.     /// Internally, a std::vector<> is used to store  

6.     /// delegate objects. Delegates are invoked in the  

7.     /// order in which they have been registered.  

8. {  

9. public:  

10.     typedef SharedPtr         DelegatePtr;  

11.     typedef std::vector     Delegates;  

12.     typedef typename Delegates::iterator Iterator;  

13.   

14. public:  

15.     DefaultStrategy()  

16.     {  

17.     }  

18.   

19.     DefaultStrategy(const DefaultStrategy& s):  

20.         _delegates(s._delegates)  

21.     {  

22.     }  

23.   

24.     ~DefaultStrategy()  

25.     {  

26.     }  

27.   

28.     void notify(const void* sender, TArgs& arguments)  

29.     {  

30.         for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)  

31.         {  

32.             (*it)->notify(sender, arguments);  

33.         }  

34.     }  

35.   

36.     void add(const TDelegate& delegate)  

37.     {  

38.         _delegates.push_back(DelegatePtr(static_cast(delegate.clone())));  

39.     }  

40.   

41.     void remove(const TDelegate& delegate)  

42.     {  

43.         for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)  

44.         {  

45.             if (delegate.equals(**it))  

46.             {  

47.                 (*it)->disable();  

48.                 _delegates.erase(it);  

49.                 return;  

50.             }  

51.         }  

52.     }  

53.   

54.     DefaultStrategy& operator = (const DefaultStrategy& s)  

55.     {  

56.         if (this != &s)  

57.         {  

58.             _delegates = s._delegates;  

59.         }  

60.         return *this;  

61.     }  

62.   

63.     void clear()  

64.     {  

65.         for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)  

66.         {  

67.             (*it)->disable();  

68.         }  

69.         _delegates.clear();  

70.     }  

71.   

72.     bool empty() const  

73.     {  

74.         return _delegates.empty();  

75.     }  

76.   

77. protected:  

78.     Delegates _delegates;  

79. };  

        哦，明白了，DefaultStrategy是一组委托的集合，内部存在的_delegates定义如下：

[cpp] view plaincopy

1. std::vector>  _delegate  

        DefaultStrategy可以被理解成一组目标的代理。在DefaultStrategy的notify函数中，我们可以设定，当一个事件发生，要送给多个目标时，所采取的策略。NotificationStrategy，PriorityStrategy，DefaultStrategy，FIFOStrategy之间的区别也就在于此。

        最后来看一下BasicEvent类。它的定义是：

[cpp] view plaincopy

1. template <class TArgs, class TMutex = FastMutex>   

2. class BasicEvent: public AbstractEvent <   

3.     TArgs, DefaultStrategy >,  

4.     AbstractDelegate,  

5.     TMutex  

6. >  

7.     /// A BasicEvent uses the DefaultStrategy which   

8.     /// invokes delegates in the order they have been registered.  

9.     ///  

10.     /// Please see the AbstractEvent class template documentation  

11.     /// for more information.  

12. {  

13. public:  

14.     BasicEvent()  

15.     {  

16.     }  

17.   

18.     ~BasicEvent()  

19.     {  

20.     }  

21.   

22. private:  

23.     BasicEvent(const BasicEvent& e);  

24.     BasicEvent& operator = (const BasicEvent& e);  

25. };  

26.   

27. AbstractEvent定义为：  

28. template <class TArgs, class TStrategy, class TDelegate, class TMutex = FastMutex>   

29. class AbstractEvent  

30. {  

31. public:  

32.     AbstractEvent():   

33.         _executeAsync(this, &AbstractEvent::executeAsyncImpl),  

34.         _enabled(true)  

35.     {  

36.     }  

37.   

38.     AbstractEvent(const TStrategy& strat):   

39.         _executeAsync(this, &AbstractEvent::executeAsyncImpl),  

40.         _strategy(strat),  

41.         _enabled(true)  

42.     {     

43.     }  

44.   

45.     virtual ~AbstractEvent()  

46.     {  

47.     }  

48.   

49.     void operator += (const TDelegate& aDelegate)  

50.     {  

51.         typename TMutex::ScopedLock lock(_mutex);  

52.         _strategy.add(aDelegate);  

53.     }  

54.       

55.     void operator -= (const TDelegate& aDelegate)  

56.     {  

57.         typename TMutex::ScopedLock lock(_mutex);  

58.         _strategy.remove(aDelegate);  

59.     }  

60.       

61.     void operator () (const void* pSender, TArgs& args)  

62.     {  

63.         notify(pSender, args);  

64.     }  

65.       

66.     void operator () (TArgs& args)  

67.     {  

68.         notify(0, args);  

69.     }  

70.   

71.     void notify(const void* pSender, TArgs& args)  

72.     {  

73.         Poco::ScopedLockWithUnlock lock(_mutex);  

74.           

75.         if (!_enabled) return;  

76.           

77.         TStrategy strategy(_strategy);  

78.         lock.unlock();  

79.         strategy.notify(pSender, args);  

80.     }  

81.   

82.     ActiveResult notifyAsync(const void* pSender, const TArgs& args)  

83.     {  

84.         NotifyAsyncParams params(pSender, args);  

85.         {  

86.             typename TMutex::ScopedLock lock(_mutex);  

87.                   

88.             params.ptrStrat = SharedPtr(new TStrategy(_strategy));  

89.             params.enabled  = _enabled;  

90.         }  

91.         ActiveResult result = _executeAsync(params);  

92.         return result;  

93.     }  

94.         // …….  

95.   

96. protected:  

97.     struct NotifyAsyncParams  

98.     {  

99.         SharedPtr ptrStrat;  

100.         const void* pSender;  

101.         TArgs       args;  

102.         bool        enabled;  

103.           

104.         NotifyAsyncParams(const void* pSend, const TArgs& a):ptrStrat(), pSender(pSend), args(a), enabled(true)  

105.         {  

106.         }  

107.     };  

108.   

109.     ActiveMethod _executeAsync;  

110.   

111.     TArgs executeAsyncImpl(const NotifyAsyncParams& par)  

112.     {  

113.         if (!par.enabled)  

114.         {  

115.             return par.args;  

116.         }  

117.   

118.   

119.         NotifyAsyncParams params = par;  

120.         TArgs retArgs(params.args);  

121.         params.ptrStrat->notify(params.pSender, retArgs);  

122.         return retArgs;  

123.     }  

124.   

125.     TStrategy _strategy; /// The strategy used to notify observers.  

126.     bool      _enabled;  /// Stores if an event is enabled. Notfies on disabled events have no effect  

127.                          /// but it is possible to change the observers.  

128.     mutable TMutex _mutex;  

129.   

130. private:  

131.     AbstractEvent(const AbstractEvent& other);  

132.     AbstractEvent& operator = (const AbstractEvent& other);  

133. };  

        从AbstractEvent类中，我们看到AbstractEvent类中存在了一个TStrategy的对象_strategy。接口上则重载了+=函数，用来把所需的目标对象加入_strategy中，完成注册功能。重载了operator ()，用于触发事件。
        于是同步事件所有的步骤便被串了起来。

5.2 异步事件

        理解了同步事件后，让我们来看异步事件。这还是让我们从一个例子说起：

[cpp] view plaincopy

1. #include "Poco/BasicEvent.h"  

2. #include "Poco/Delegate.h"  

3. #include "Poco/ActiveResult.h"  

4. #include   

5.   

6. using Poco::BasicEvent;  

7. using Poco::Delegate;  

8. using Poco::ActiveResult;  

9.   

10. class TargetAsync  

11. {  

12. public:  

13.     void onAsyncEvent(const void* pSender, int& arg)  

14.     {  

15.         std::cout << "onAsyncEvent: " << arg <<  " Current Thread Id is :" << GetCurrentThreadId() << " "<< std::endl;  

16.         return;  

17.     }  

18. };  

19.   

20. template<typename RT> class Source  

21. {  

22. public:  

23.     BasicEvent<int> theEvent;  

24.     ActiveResult AsyncFireEvent(int n)  

25.     {  

26.         return ActiveResult (theEvent.notifyAsync(this, n));  

27.     }  

28. };  

29.   

30. int main(int argc, char** argv)  

31. {  

32.     Source<int> source;  

33.     TargetAsync target;  

34.     std::cout <<  "Main Thread Id is :" << GetCurrentThreadId() << " " << std::endl;  

35.     source.theEvent += Poco::delegate(&target, &TargetAsync::onAsyncEvent);  

36.     ActiveResult<int> Targs = source.AsyncFireEvent(43);  

37.     Targs.wait();  

38.     std::cout << "onEventAsync: " << Targs.data() << std::endl;  

39.     source.theEvent -= Poco::delegate(&target, &TargetAsync::onAsyncEvent);  

40.   

41.     return 0;  

42. }  

        例子里可以看出，同同步事件不同的是，触发事件时，我们调用的是notifyAsync接口。在这个接口里，NotifyAsyncParams对象被创建，并被交由一个主动对象_executeAsync执行。关于主动对象ActiveMethod的介绍，可以从前面的文章POCOC++库学习和分析 -- 线程（四）中找到。

POCO C++库学习和分析 -- 数据类型转换

         文章写到这里，Foundation库中的功能已经介绍过半了。在接下去介绍其他模块之前，我们先来回顾一下前面的内容。前面的内容包括了：

         1. SharedLibrary模块(插件技术)  《Foundation库SharedLibrary模块分析》

         2. 线程(锁，线程，线程池，定时器，任务，主动对象) 《线程》

         3. 内存管理(智能指针，内存池，自动释放的对象池，对象工厂)  《内存管理》

         4. 进程(进程，进程通讯)  《进程》

         5. 消息和事件(同步/异步消息传递，消息队列)  《通知和事件》

        有了这些模块，我们就可以搭建起一个本地程序的框架了(当然这不包括绘图和显示，Poco库不提供这些功能)。程序的框架很重要，就如同人的骨架和血液一样，决定了一个程序的结构，间接的影响了程序的可修改性和可维护性，但这还不够，要写出一个完整的程序，我们还需要其他的一些部分，这些部分也很重要，就如同人的肌肉和衣服。

         下面介绍Foundation库中关于转换的几个类：

1. ByteOrder

         ByteOrder提供了一系列的静态函数用于字节序的转换。在使用这个类之前，让我们先了解一下它所解决问题。它主要用来解决big-endian和litter-endian的问题。

1.1 big-endian和litter-endian

         big-endian和litter-endian指的是读取存储时的数据解释方式。它们只和多字节类型的数据有关，比如说int,short,long型，而对单字节数据byte却没有影响。
                    litter-endian：将低序字节存储在起始地址(低位字节存储在内存中低位地址)。

                    big-endian：将高序字节存储在起始地址(高位字节存储在内存中低位地址)。

         举个例子，int a = 0x01020304
         在BIG-ENDIAN的情况下存放为：
                     字节号  0        1        2      3
　　              数据    01      02      03   04
         在LITTLE-ENDIAN的情况下存放为：
                    字节号  0         1        2     3
　　            数据    04        03      02   01

          再举一个，int a =0x1234abcd
         在BIG-ENDIAN的情况下存放为：
                    字节号  0      1      2      3
　　            数据    12     34    ab    cd
         在LITTLE-ENDIAN的情况下存放为：
                   字节号  0       1     2      3
　　           数据    cd      ab    34    12

1.2 主机序和网络序

         主机序是读取计算机内存数据时的解释方式，它和CPU、操作系统的类型相关，分为litter-endian和big-endian。X86架构的cpu不管操作系统是NT还是UNIX系的，都是小字节序，而PowerPC 、SPARC和Motorola处理器则很多是大字节序。下面是一张字节序和CPU、操作系统的关系表。

         处理器                     操作系统           字节排序
         Alpha                       全部                Little endian
         HP-PA                     NT                   Little endian
         HP-PA                     UNIX               Big endian
         Intelx86                  全部                 Little endian (x86系统是小端字节序系统)
         Motorola680x()     全部                  Bigendian
         MIPS                       NT                   Littleendian
         MIPS                      UNIX                Big endian
         PowerPC               NT                   Little endian
         PowerPC               非NT               Big endian   (PPC系统是大端字节序系统)
         RS/6000                UNIX               Big endian
         SPARC                  UNIX                Big endian
         IXP1200                ARM核心         全部 Little endian

1.3 主机序和网络序和大头小头引起的问题

        如果在两台字节序不同的主机之间进行网络通讯，大小字节序的问题就会出现。通常的做法是在小字节序一端的主机进行处理（网络序始终是大字节序），小字节序的主机在发送数据前，转换数据为大字节序，而在接受时，把大字节序数据转成小字节序。

         如果在字节序相同的两台机器之间进行通讯，可以不用考虑字节序问题。
         同样的是在两台机器之间，用java语言编写通讯程序时，可以不考虑字节序问题。JAVA字节序与网络字节序都是big-endian.

1.4 ByteOrder静态函数

         ByteOrder提供了一组静态的Api去解决这个问题。
         1) IntXXflipBytes(IntXX value)
             字节翻转排序，实现大小字节序的转换
         2) IntXXtoBigEndian(IntXX value)
             把数据从本机序转成大字节序。如果本机序是本身就是大字节序，返回结果为转之前数据。
         3) IntXXtoLittleEndian(IntXX value)
             把数据从本机序转成小字节序。如果本机序是本身就是小字节序，返回结果为转之前数据。
         4) IntXXfromBigEndian(IntXX value)
             把数据从大字节序转成本机序。如果本机序是本身就是大字节序，返回结果为转之前数据。
         5) IntXXfromLittleEndian(IntXX value)
             把数据从小字节序转成本机序。如果本机序是本身就是小字节序，返回结果为转之前数据。
         6) IntXXtoNetwork(IntXX value)
             把数据从本机序转成网络序。如果本机序是本身就是大字节序，返回结果为转之前数据。
         7) IntXXfromNetwork(IntXX value)
             把数据从网络序转成本机序。如果本机序是本身就是大字节序，返回结果为转之前数据。

             下面来看一个ByteOrder的例子：

[cpp] view plaincopy

1. #include "Poco/ByteOrder.h"  

2. #include   

3. using Poco::ByteOrder;  

4. using Poco::UInt16;  

5. int main(int argc, char** argv)  

6. {  

7. #ifdef POCO_ARCH_LITTLE_ENDIAN  

8.     std::cout << "little endian" << std::endl;  

9. #else  

10.     std::cout << "big endian" << std::endl;  

11. #endif  

12.     UInt16 port = 80;  

13.     UInt16 networkPort = ByteOrder::toNetwork(port);  

14.     return 0;  

15. }  

2. Any

         Poco中的Any类，来自于Boost库中的Any类。Any类主要用于数据库读取时的数据保存和解析。它能够将任意类型值保存进去，并能把任意类型值读出来。Boost::any的作者认为，所谓generic type有三个层面的解释方法：
         1. 类似variant类型那样任意进行类型转换，可以保存一个(int)5进去，读一个(string)"5"出来。在variant类型内部使用union实现，使用灵活但效率较低。
         2. 区别对待包含值的类型，保存一个(int)5进去，不会被隐式转换为(string)'5'或者(double)5.0，读出来还是(int)5。这样效率较高且类型安全，不必担心ambiguousconversions
         3. 对包含值类型不加区别，例如把所有保存的值强制转换为void*保存。读取时再有程序员判断其类型。这样效率虽最高但无法保证类型安全

         boost::any就选择了第二层面的设计思路，它允许用户将任意类型值保存进一个any类型变量，但内部并不改变值的类型，并提供方法让用户在使用时主动/被动进行类型判断。关于Poco::Any的进一步描述和实现技巧，可以看刘未鹏大大的《boost源码剖析之：泛型指针类any之海纳百川》和hityct1大大的《boost::any的用法、优点和缺点以及源代码分析》。

         下面是Poco::Any的一个例子：

[cpp] view plaincopy

1. #include "Poco/Any.h"  

2. #include "Poco/Exception.h"  

3. #include   

4.   

5. using Poco::Any;  

6. using Poco::AnyCast;  

7. using Poco::RefAnyCast;  

8.   

9. int main(int argc, char** argv)  

10. {  

11.     Any any(42);  

12.     int i = AnyCast<int>(any);              // okay  

13.     int& ri = RefAnyCast<int>(any);         // okay  

14.     try  

15.     {  

16.         short s = AnyCast<short>(any);  // throws BadCastException  

17.                 assert(any.type() == typeid(int));    

18.     }  

19.     catch (Poco::BadCastException&)  

20.     {}  

21.     return 0;  

22. }  

         最后给出Poco::Any的类图

3. DynamicAny

        Poco::DynamicAny在generic type的处理思路上采用的是上述第一种和第二种思路的结合。
         首先它支持有限类型之间的自动类型转换，可以保存一个(int)5进去，读一个(string)"5"出来。所谓有限类型很好理解，因为类型转化的本质是对内存数据的不同解释，如果转化前的数据类型和转化后的数据类型都是不定且无限，作为类的书写者，实在是不能想象的。而有限类型的转化至少我们可以枚举，而事实上这正是Poco::DynamicAny实现时所做的。Poco::DynamicAny支持Int8、Int16、Int32、Int64UInt8、UInt16、UInt32、UInt64、bool、float、double、char、std::string、long、unsigned long、std::vector、DateTime、LocalDateTime、Timestamp类型之间的转化。为此Poco::DynamicAny提供了成员函数convert和operator T()函数去实现上述的功能。当转换失败的时候会抛出异常。
         第二，在有限类型内部，Poco::DynamicAny提供函数完成与Poco::Any类类似的功能。事实上DynamicAny::extract()函数和Any类的友元函数AnyCast()是基本一致的。下面是二者代码：

[cpp] view plaincopy

1. template <typename T> const T& DynamicAny::extract() const  

2.         /// Returns a const reference to the actual value.  

3.         ///  

4.         /// Must be instantiated with the exact type of  

5.         /// the stored value, otherwise a BadCastException  

6.         /// is thrown.  

7.         /// Throws InvalidAccessException if DynamicAny is empty.  

8. {  

9.     if (_pHolder && _pHolder->type() == typeid(T))  

10.     {  

11.         DynamicAnyHolderImpl* pHolderImpl = static_cast*>(_pHolder);  

12.         return pHolderImpl->value();  

13.     }  

14.     else if (!_pHolder)  

15.         throw InvalidAccessException("Can not extract empty value.");  

16.     else  

17.         throw BadCastException(format("Can not convert %s to %s.",  

18.             _pHolder->type().name(),  

19.             typeid(T).name()));  

20. }  

[cpp] view plaincopy

1. template <typename ValueType>  

2. ValueType* AnyCast(Any* operand)  

3.     /// AnyCast operator used to extract the ValueType from an Any*. Will return a   

4.   

5.   

6. pointer  

7.     /// to the stored value.   

8.     ///  

9.     /// Example Usage:   

10.     ///     MyType* pTmp = AnyCast(pAny).  

11.     /// Will return NULL if the cast fails, i.e. types don't match.  

12. {  

13.     return operand && operand->type() == typeid(ValueType)  

14.                 ? &static_cast*>(operand->_content)->_held  

15.                 : 0;  

16. }  

         看到这里，我们实际上就明白了Poco::DynamicAny和Poco::Any的使用场景。对于用户自建数据类型，毫无疑问只能使用Poco::Any类。而对于C++语言内置的数据类型，使用Poco::DynamicAny，因为Poco::DynamicAny不仅对于内置数据类型提供了类似Poco::Any的接口，而且还提供了相互之间的转换功能。
         在Poco::DynamicAny的实现上，使用了模板特化技术，用于在不同数据类型之间的转换，关于这一点，也可以理解成枚举。实质上就是说把程序员在不同数据间的转换工作在Poco::DynamicAny类中先实现了一遍，程序员只需要直接调用Poco::DynamicAny就可以了。

         对于convert()/operatorT()函数和extract()函数的区别如下：
             T convert()/operator T()/void convert(T& val)             const T& extract()
               返回一个拷贝                                                              返回一个常量引用
               自动转变类型                                                              不会自动转变类型
               比Any慢                                                                       同Any一样快

         下面是Poco::DynamicAny的类图：

         在介绍完这个类之前提一句，有兴趣的同学也可以去考察一下boost库中的boost::variant和boost::lexical_cast，看一看它们和Poco::DynamicAny的异同。

POCO C++库学习和分析 -- 哈希

1. Hash概论

        在理解Poco中的Hash代码之前，首先需要了解一下Hash的基本理论。下面的这些内容和教课书上的内容并没有太大的差别。

1.1 定义

        下面这几段来自于百度百科：
        Hash：一般翻译做"散列"，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
       Hashtable：散列表，也叫哈希表，是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
       * 若结构中存在关键字和K相等的记录，则必定存储在f(K）的位置上。由此，不需比较便可直接取得所查记录。这个对应关系f称为散列函数(Hash function），按这个思想建立的表为散列表。
       * 对不同的关键字可能得到同一散列地址，即key1≠key2，而f(key1)=f(key2），这种现象称冲突。具有相同函数值的关键字对该散列函数来说称做同义词。
       * 综上所述，根据散列函数H(key）和处理冲突的方法将一组关键字映象到一个有限的连续的地址集（区间）上，并以关键字在地址集中的“象”， 作为这条记录在表中的存储位置，这种表便称为散列表，这一映象过程称为散列造表或散列，所得的存储位置称散列地址。这个现象也叫散列桶，在散列桶中，只能通过顺序的方式来查找，一般只需要查找三次就可以找到。科学家计算过，当重载因子不超过75%，查找效率最高。
       * 若对于关键字集合中的任一个关键字，经散列函数映象到地址集合中任何一个地址的概率是相等的，则称此类散列函数为均匀散列函数（Uniform Hash function），这就是使关键字经过散列函数得到一个“随机的地址”，从而减少冲突。

1.2 Hash table查找效率

       对于Hash table来言，理论上查找效率为O(1)。但在现实世界中，查找的过程存在冲突现象。产生的冲突少，查找效率就高，产生的冲突多，查找效率就低。因此，影响产生冲突多少的因素，也就是影响查找效率的因素。影响产生冲突多少有以下三个因素：
       1. 散列函数是否均匀；
       2. 处理冲突的方法；
       3. 散列表的装填因子。
       散列表的装填因子定义为：α= 填入表中的元素个数 / 散列表的长度
       实际上，散列表的平均查找长度是装填因子α的函数，只是不同处理冲突的方法有不同的函数。

1.3 Poco中的Hash内容

       Poco中的hash内容主要关注于Hash表的应用。下面是Poco中相关于Hash的类图：

       我们看到Poco的Hash内容主要被分成3部分：
       1. Hash函数。Poco提供了一组Hash函数用于，生成hash值。同时提供了模板类HashFunction，通过仿函式提供对任意数据结构生成hash值的功能。
       2. Hashtable(哈希表)。Poco中实现了3种哈希表，分别是SimpleHashTable, HashTable,LinearHashTable。
       3. 在哈希表上的应用，封装出hash map和hash set。

2. Hash函数

       Hash函数是解决hash冲突的第一个要素。
       Poco中提供了一组Hash函数，用于产生hash值。其定义如下：

[cpp] view plaincopy

1. inline std::size_t hash(Int8 n)  

2. {  

3.     return static_cast<std::size_t>(n)*2654435761U;   

4. }  

5.   

6. inline std::size_t hash(UInt8 n)  

7. {  

8.     return static_cast<std::size_t>(n)*2654435761U;   

9. }  

10.   

11. inline std::size_t hash(Int16 n)  

12. {  

13.     return static_cast<std::size_t>(n)*2654435761U;   

14. }  

15.   

16.   

17. inline std::size_t hash(UInt16 n)  

18. {  

19.     return static_cast<std::size_t>(n)*2654435761U;   

20. }  

21.   

22. inline std::size_t hash(Int32 n)  

23. {  

24.     return static_cast<std::size_t>(n)*2654435761U;   

25. }  

26.   

27. inline std::size_t hash(UInt32 n)  

28. {  

29.     return static_cast<std::size_t>(n)*2654435761U;   

30. }  

31.   

32.   

33. inline std::size_t hash(Int64 n)  

34. {  

35.     return static_cast<std::size_t>(n)*2654435761U;   

36. }  

37.   

38. inline std::size_t hash(UInt64 n)  

39. {  

40.     return static_cast<std::size_t>(n)*2654435761U;   

41. }  

42.   

43. std::size_t hash(const std::string& str)  

44. {  

45.     std::size_t h = 0;  

46.     std::string::const_iterator it  = str.begin();  

47.     std::string::const_iterator end = str.end();  

48.     while (it != end)  

49.     {  

50.         h = h * 0xf4243 ^ *it++;  

51.     }  

52.     return h;  

53. }  

       这里就不对hash函数做过多叙述了，下面列出一些其他的常用hash函数。网上有专门的论述，并对不同的hash函数效果做了比较，有兴趣的话可以google一下。
       附：各种哈希函数的C语言程序代码

[cpp] view plaincopy

1. unsigned int SDBMHash(char *str)  

2. {  

3.     unsigned int hash = 0;  

4.     while (*str)  

5.     {  

6.         // equivalent to: hash = 65599*hash + (*str++);  

7.         hash = (*str++) + (hash << 6) + (hash << 16) - hash;  

8.     }  

9.     return (hash & 0x7FFFFFFF);  

10. }  

11.   

12.   

13. // RS Hash   

14. unsigned int RSHash(char *str)  

15. {  

16.     unsigned int b = 378551;  

17.     unsigned int a = 63689;  

18.     unsigned int hash = 0;  

19.     while (*str)  

20.     {  

21.         hash = hash * a + (*str++);  

22.         a *= b;  

23.     }  

24.     return (hash & 0x7FFFFFFF);  

25. }  

26.   

27.   

28. // JS Hash   

29. unsigned int JSHash(char *str)  

30. {  

31.     unsigned int hash = 1315423911;  

32.     while (*str)  

33.     {  

34.         hash ^= ((hash << 5) + (*str++) + (hash >> 2));  

35.     }  

36.     return (hash & 0x7FFFFFFF);  

37. }  

38.   

39.   

40. // P. J. Weinberger Hash   

41. unsigned int PJWHash(char *str)  

42. {  

43.     unsigned int BitsInUnignedInt = (unsigned int)(sizeof(unsigned int) * 8);  

44.     unsigned int ThreeQuarters  = (unsigned int)((BitsInUnignedInt  * 3) / 4);  

45.     unsigned int OneEighth = (unsigned int)(BitsInUnignedInt / 8);  

46.     unsigned int HighBits = (unsigned int)(0xFFFFFFFF) << (BitsInUnignedInt - OneEighth);  

47.     unsigned int hash   = 0;  

48.     unsigned int test   = 0;  

49.     while (*str)  

50.     {  

51.         hash = (hash << OneEighth) + (*str++);  

52.         if ((test = hash & HighBits) != 0)  

53.         {  

54.             hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));  

55.         }  

56.     }  

57.     return (hash & 0x7FFFFFFF);  

58. }  

59.   

60.   

61. // ELF Hash   

62. unsigned int ELFHash(char *str)  

63. {  

64.     unsigned int hash = 0;  

65.     unsigned int x  = 0;  

66.     while (*str)  

67.     {  

68.         hash = (hash << 4) + (*str++);  

69.         if ((x = hash & 0xF0000000L) != 0)  

70.         {  

71.             hash ^= (x >> 24);  

72.             hash &= ~x;  

73.         }  

74.     }  

75.     return (hash & 0x7FFFFFFF);  

76. }  

77.   

78.   

79. // BKDR Hash   

80. unsigned int BKDRHash(char *str)  

81. {  

82.     unsigned int seed = 131; // 31 131 1313 13131 131313 etc..  

83.     unsigned int hash = 0;  

84.     while (*str)  

85.     {  

86.         hash = hash * seed + (*str++);  

87.     }  

88.     return (hash & 0x7FFFFFFF);  

89. }  

90.   

91.   

92. // DJB Hash   

93. unsigned int DJBHash(char *str)  

94. {  

95.     unsigned int hash = 5381;  

96.     while (*str)  

97.     {  

98.         hash += (hash << 5) + (*str++);  

99.     }  

100.     return (hash & 0x7FFFFFFF);  

101. }  

102.   

103.   

104. // AP Hash   

105. unsigned int APHash(char *str)  

106. {  

107.     unsigned int hash = 0;  

108.     int i;  

109.     for (i=0; *str; i++)  

110.     {  

111.         if ((i & 1) == 0)  

112.         {  

113.             hash ^= ((hash << 7) ^ (*str++) ^ (hash >> 3));  

114.         }  

115.         else  

116.         {  

117.             hash ^= (~((hash << 11) ^ (*str++) ^ (hash >> 5)));  

118.         }  

119.     }  

120.     return (hash & 0x7FFFFFFF);  

121. }  

122.   

123.   

124. unsigned int hash(char *str)  

125. {  

126.     register unsigned int h;  

127.     register unsigned char *p;  

128.     for(h=0, p = (unsigned char *)str; *p ; p++)  

129.         h = 31 * h + *p;  

130.     return h;  

131. }  

[cpp] view plaincopy

1. // PHP中出现的字符串Hash函数  

2. static unsigned long hashpjw(char *arKey, unsigned int nKeyLength)  

3. {  

4.     unsigned long h = 0, g;  

5.     char *arEnd=arKey+nKeyLength;  

6.   

7.     while (arKey < arEnd) {  

8.         h = (h << 4) + *arKey++;  

9.         if ((g = (h & 0xF0000000))) {  

10.             h = h ^ (g >> 24);  

11.             h = h ^ g;  

12.         }  

13.     }  

14.     return h;  

15. }  

[cpp] view plaincopy

1. // OpenSSL中出现的字符串Hash函数  

2. unsigned long lh_strhash(char *str)  

3. {  

4.     int i,l;  

5.     unsigned long ret=0;  

6.     unsigned short *s;  

7.   

8.     if (str == NULL) return(0);  

9.     l=(strlen(str)+1)/2;  

10.     s=(unsigned short *)str;  

11.     for (i=0; i  

12.         ret^=(s[i]<<(i&0x0f));  

13.         return(ret);  

14. }   

15.   

16. /* The following hash seems to work very well on normal text strings 

17. * no collisions on /usr/dict/words and it distributes on %2^n quite 

18. * well, not as good as MD5, but still good. 

19. */  

20. unsigned long lh_strhash(const char *c)  

21. {  

22.     unsigned long ret=0;  

23.     long n;  

24.     unsigned long v;  

25.     int r;  

26.   

27.   

28.     if ((c == NULL) || (*c == '\0'))  

29.         return(ret);  

30.     /* 

31.     unsigned char b[16]; 

32.     MD5(c,strlen(c),b); 

33.     return(b[0]|(b[1]<<8)|(b[2]<<16)|(b[3]<<24)); 

34.     */  

35.   

36.   

37.     n=0x100;  

38.     while (*c)  

39.     {  

40.         v=n|(*c);  

41.         n+=0x100;  

42.         r= (int)((v>>2)^v)&0x0f;  

43.         ret=(ret(32-r));  

44.         ret&=0xFFFFFFFFL;  

45.         ret^=v*v;  

46.         c++;  

47.     }  

48.     return((ret>>16)^ret);  

49. }  

[cpp] view plaincopy

1. // MySql中出现的字符串Hash函数  

2. #ifndef NEW_HASH_FUNCTION  

3.   

4. /* Calc hashvalue for a key */  

5. static uint calc_hashnr(const byte *key,uint length)  

6. {  

7.     register uint nr=1, nr2=4;  

8.     while (length--)  

9.     {  

10.         nr^= (((nr & 63)+nr2)*((uint) (uchar) *key++))+ (nr << 8);  

11.         nr2+=3;  

12.     }  

13.     return((uint) nr);  

14. }  

15.   

16.   

17. /* Calc hashvalue for a key, case indepenently */  

18. static uint calc_hashnr_caseup(const byte *key,uint length)  

19. {  

20.     register uint nr=1, nr2=4;  

21.     while (length--)  

22.     {  

23.         nr^= (((nr & 63)+nr2)*((uint) (uchar) toupper(*key++)))+ (nr << 8);  

24.         nr2+=3;  

25.     }  

26.     return((uint) nr);  

27. }  

28.   

29. #else  

30.   

31. /* 

32. * Fowler/Noll/Vo hash 

33. * 

34. * The basis of the hash algorithm was taken from an idea sent by email to the 

35. * IEEE Posix P1003.2 mailing list from Phong Vo (kpv@research.att.com) and 

36. * Glenn Fowler (gsf@research.att.com). Landon Curt Noll (chongo@toad.com) 

37. * later improved on their algorithm. 

38. * 

39. * The magic is in the interesting relationship between the special prime 

40. * 16777619 (2^24 + 403) and 2^32 and 2^8. 

41. * 

42. * This hash produces the fewest collisions of any function that we've seen so 

43. * far, and works well on both numbers and strings. 

44. */  

45.   

46. uint calc_hashnr(const byte *key, uint len)  

47. {  

48.     const byte *end=key+len;  

49.     uint hash;  

50.     for (hash = 0; key < end; key++)  

51.     {  

52.         hash *= 16777619;  

53.         hash ^= (uint) *(uchar*) key;  

54.     }  

55.     return (hash);  

56. }  

57.   

58. uint calc_hashnr_caseup(const byte *key, uint len)  

59. {  

60.     const byte *end=key+len;  

61.     uint hash;  

62.     for (hash = 0; key < end; key++)  

63.     {  

64.         hash *= 16777619;  

65.         hash ^= (uint) (uchar) toupper(*key);  

66.     }  

67.     return (hash);  

68. }  

69. #endif  

3. Hash 表

       我们接下去分析Poco中Hash表的实现。Poco中实现了3种哈希表，分别是SimpleHashTable, HashTable,LinearHashTable。它们的实现对应了当出现冲突时，解决冲突的不同方法。首先我们看一下通用的解决方法。
       1. 线性探测。当出现碰撞时，顺序依次查询后续位置，直到找到空位。《利用线性探测法构造散列表》
       2. 双重散列法。当使用第一个散列Hash函数，出现碰撞时，用第二个散列函数去寻找空位
       3. 拉链法。出现碰撞的时候，使用list存储碰撞数据
       4. 线性哈希，linear hash。立刻分裂或者延迟分裂。通过分裂，控制桶的高度，每次分裂时，会重新散列碰撞元素。《linearhashing》

       SimpleHashTable的实现对应了方法一；HashTable对应了方法3；LinearHashTable对应了方法4。

3.1 SimpleHashTable

       从类图里我们看到，SimpleHashTable是一个HashEntry容器， 内部定义如下：

[cpp] view plaincopy

1. std::vector _entries  

       当插入新数据时，首先根据hash值，计算空位，然后存储；如果发现冲突，顺着计算的hash值按地址顺序依次寻找空位；如_entries容器无空位，则抛出异常。

[cpp] view plaincopy

1. UInt32 insert(const Key& key, const Value& value)  

2. /// Returns the hash value of the inserted item.  

3. /// Throws an exception if the entry was already inserted  

4. {  

5.     UInt32 hsh = hash(key);  

6.     insertRaw(key, hsh, value);  

7.     return hsh;  

8. }  

9.   

10. Value& insertRaw(const Key& key, UInt32 hsh, const Value& value)  

11. /// Returns the hash value of the inserted item.  

12. /// Throws an exception if the entry was already inserted  

13. {  

14.     UInt32 pos = hsh;  

15.     if (!_entries[pos])  

16.         _entries[pos] = new HashEntry(key, value);  

17.     else  

18.     {  

19.         UInt32 origHash = hsh;  

20.         while (_entries[hsh % _capacity])  

21.         {  

22.             if (_entries[hsh % _capacity]->key == key)  

23.                 throw ExistsException();  

24.             if (hsh - origHash > _capacity)  

25.                 throw PoolOverflowException("SimpleHashTable full");  

26.             hsh++;  

27.         }  

28.         pos = hsh % _capacity;  

29.         _entries[pos] = new HashEntry(key, value);  

30.     }  

31.     _size++;  

32.     return _entries[pos]->value;  

33. }  

       SimpleHashTable进行搜索时，策略也一致。

[cpp] view plaincopy

1. const Value& get(const Key& key) const  

2. /// Throws an exception if the value does not exist  

3. {  

4.     UInt32 hsh = hash(key);  

5.     return getRaw(key, hsh);  

6. }  

7.   

8. const Value& getRaw(const Key& key, UInt32 hsh) const  

9. /// Throws an exception if the value does not exist  

10. {  

11.     UInt32 origHash = hsh;  

12.     while (true)  

13.     {  

14.         if (_entries[hsh % _capacity])  

15.         {  

16.             if (_entries[hsh % _capacity]->key == key)  

17.             {  

18.                 return _entries[hsh % _capacity]->value;  

19.             }  

20.         }  

21.         else  

22.             throw InvalidArgumentException("value not found");  

23.         if (hsh - origHash > _capacity)  

24.             throw InvalidArgumentException("value not found");  

25.         hsh++;  

26.     }  

27. }  

       SimpleHashTable没有提供删除数据的接口，只适用于数据量不大的简单应用。

3.2 HashTable

       HashTable是拉链法的一个变种。当冲突数据发生时，存储的容器是map而不是list。其内部容器定义为：

[cpp] view plaincopy

1. HashEntryMap** _entries;  

       同map相比，它实际上是把一个大map分成了很多个小map，通过hash方法寻找到小map，再通过map的find函数寻找具体数据。其插入和搜索数据函数如下：

[cpp] view plaincopy

1. UInt32 insert(const Key& key, const Value& value)  

2. /// Returns the hash value of the inserted item.  

3. /// Throws an exception if the entry was already inserted  

4. {  

5.     UInt32 hsh = hash(key);  

6.     insertRaw(key, hsh, value);  

7.     return hsh;  

8. }  

9.   

10.   

11. Value& insertRaw(const Key& key, UInt32 hsh, const Value& value)  

12. /// Returns the hash value of the inserted item.  

13. /// Throws an exception if the entry was already inserted  

14. {  

15.     if (!_entries[hsh])  

16.         _entries[hsh] = new HashEntryMap();  

17.     std::pair<typename HashEntryMap::iterator, bool> res(_entries[hsh]->insert(std::make_pair(key, value)));  

18.     if (!res.second)  

19.         throw InvalidArgumentException("HashTable::insert, key already exists.");  

20.     _size++;  

21.     return res.first->second;  

22. }  

23.   

24.   

25. const Value& get(const Key& key) const  

26. /// Throws an exception if the value does not exist  

27. {  

28.     UInt32 hsh = hash(key);  

29.     return getRaw(key, hsh);  

30. }  

31.   

32.   

33. const Value& getRaw(const Key& key, UInt32 hsh) const  

34. /// Throws an exception if the value does not exist  

35. {  

36.     if (!_entries[hsh])  

37.         throw InvalidArgumentException("key not found");  

38.   

39.     ConstIterator it = _entries[hsh]->find(key);  

40.     if (it == _entries[hsh]->end())  

41.         throw InvalidArgumentException("key not found");  

42.   

43.     return it->second;  

44. }  

       HashTable支持remove操作。

3.2 LinearHashTable

       LinearHashTable按照解决冲突的方法4实现。它内部的容器为vector>,同时还存在两个控制量_split和_front：

[cpp] view plaincopy

1. std::size_t _split;  

2. std::size_t _front;  

3. vector> _buckets;  

       它的插入操作如下：

[cpp] view plaincopy

1. std::pair<Iterator, bool> insert(const Value& value)  

2. /// Inserts an element into the table.  

3. ///  

4. /// If the element already exists in the table,  

5. /// a pair(iterator, false) with iterator pointing to the   

6. /// existing element is returned.  

7. /// Otherwise, the element is inserted an a   

8. /// pair(iterator, true) with iterator  

9. /// pointing to the new element is returned.  

10. {  

11.     std::size_t hash = _hash(value);  

12.     std::size_t addr = bucketAddressForHash(hash);  

13.     BucketVecIterator it(_buckets.begin() + addr);  

14.     BucketIterator buckIt(std::find(it->begin(), it->end(), value));  

15.     if (buckIt == it->end())  

16.     {  

17.         split();  

18.         addr = bucketAddressForHash(hash);  

19.         it = _buckets.begin() + addr;  

20.         buckIt = it->insert(it->end(), value);  

21.         ++_size;  

22.         return std::make_pair(Iterator(it, _buckets.end(), buckIt), true);  

23.     }  

24.     else  

25.     {  

26.         return std::make_pair(Iterator(it, _buckets.end(), buckIt), false);  

27.     }  

28. }  

       其中split函数是所有操作的关键：

[cpp] view plaincopy

1. void split()  

2. {  

3.     if (_split == _front)  

4.     {  

5.         _split = 0;  

6.         _front *= 2;  

7.         _buckets.reserve(_front*2);  

8.     }  

9.     Bucket tmp;  

10.     _buckets.push_back(tmp);  

11.     _buckets[_split].swap(tmp);  

12.     ++_split;  

13.     for (BucketIterator it = tmp.begin(); it != tmp.end(); ++it)  

14.     {  

15.         using std::swap;  

16.         std::size_t addr = bucketAddress(*it);  

17.         _buckets[addr].push_back(Value());  

18.         swap(*it, _buckets[addr].back());  

19.     }  

20. }  

       从上面的代码中我们可以看到，在每次插入新元素的时候，都会增加一个新的桶，并对桶_buckets[_split]进行重新散列；在_split == _front时，会把_buckets的容积扩大一倍。通过动态的增加桶的数量，这种方法降低了每个桶的高度，从而保证了搜索的效率。

4. HashMap和HashSet

       HashMap和HashSet是在LinearHashTable上的封装，使接口同stl::map和stl::set相类似，使用时非常的简单。下面来看一个例子：

[cpp] view plaincopy

1. #include "Poco/HashMap.h"  

2. int main()  

3. {  

4.     typedef HashMap<int, int> IntMap;  

5.     IntMap hm;  

6.       

7.     for (int i = 0; i < N; ++i)  

8.     {  

9.         std::pair<IntMap::Iterator, bool> res = hm.insert(IntMap::ValueType(i, i*2));  

10.         IntMap::Iterator it = hm.find(i);  

11.     }         

12.       

13.     assert (!hm.empty());  

14.       

15.     for (int i = 0; i < N; ++i)  

16.     {  

17.         IntMap::Iterator it = hm.find(i);  

18.     }  

19.       

20.     for (int i = 0; i < N; ++i)  

21.     {  

22.         std::pair<IntMap::Iterator, bool> res = hm.insert(IntMap::ValueType(i, 0));  

23.     }     

24.         return 0;  

25. }     

POCO C++库学习和分析 -- Cache

1. Cache概述

        在STL::map或者STL::set中，容器的尺寸是没有上限的，数目可以不断的扩充。并且在STL的容器中，元素是不会自动过期的，除非显式的被删除。Poco的Cache可以被看成是STL中容器的一个扩充，容器中的元素会自动过期(即失效)。在Poco实现的Cache框架中，基础的过期策略有两种。一种是LRU(LastRecent Used)，另外一种是基于时间的过期(Time based expiration)。在上述两种过期策略之上，还提供了两者之间的混合。

        下面是相关的类：
        1. LRUCache: 最近使用Cache。在内部维护一个Cache的最大容量M，始终只保存M个元素于Cache内部，当第M+1元素插入Cache中时，最先被放入Cache中的元素将失效。
        2. ExpireCache: 时间过期Cache。在内部统一管理失效时间T，当元素插入Cache后，超过时间T，则删除。
        3. AccessExpireCache: 时间过期Cache。同ExpireCache不同的是，当元素被访问后，重新开始计算该元素的超时时间，而不是只从元素插入时开始计时。
        4. UniqueExpireCache: 时间过期Cache。同ExpireCache不同的是，每一个元素都有自己单独的失效时间。
        5. UniqueAccessExpireCache：时间过期Cache。同AccessExpireCache不同的是，每一个元素都有自己单独的失效时间。
        6. ExpireLRUCache：时间过期和LRU策略的混合体。当时间过期和LRU任一过期条件被触发时，容器中的元素失效。
        7. AccessExpireLRUCache：时间过期和LRU策略的混合体。同ExpireLRUCache相比，当元素被访问后，重新开始计算该元素的超时时间，而不是只从元素插入时开始计时。
        8. UniqueExpireLRUCache：时间过期和LRU策略的混合体。同ExpireLRUCache相比，每一个元素都有自己单独的失效时间。
        9. UniqueAccessExpireLRUCache：时间过期和LRU策略的混合体。同UniqueExpireLRUCache相比，当元素被访问后，重新开始计算该元素的超时时间，而不是只从元素插入时开始计时。

2. Cache的内部结构

2.1 Cache类

        下面是Poco中Cache的类图：

        从类图中我们可以看到所有的Cache都有一个对应的strategy类。事实上strategy类负责快速搜索Cache中的过期元素。Cache和strategy采用了Poco中的同步事件机制(POCOC++库学习和分析 -- 通知和事件（四） )。

        让我们来看AbstractCache的定义：

[cpp] view plaincopy

1. template <class TKey, class TValue, class TStrategy, class TMutex = FastMutex, class TEventMutex = FastMutex>   

2. class AbstractCache  

3.     /// An AbstractCache is the interface of all caches.   

4. {  

5. public:  

6.     FIFOEvent<const KeyValueArgs, TEventMutex > Add;  

7.     FIFOEvent<const KeyValueArgs, TEventMutex > Update;  

8.     FIFOEvent<const TKey, TEventMutex>                         Remove;  

9.     FIFOEvent<const TKey, TEventMutex>                         Get;  

10.     FIFOEvent<const EventArgs, TEventMutex>                    Clear;  

11.   

12.     typedef std::map > DataHolder;  

13.     typedef typename DataHolder::iterator       Iterator;  

14.     typedef typename DataHolder::const_iterator ConstIterator;  

15.     typedef std::set                      KeySet;  

16.   

17.     AbstractCache()  

18.     {  

19.         initialize();  

20.     }  

21.   

22.     AbstractCache(const TStrategy& strat): _strategy(strat)  

23.     {  

24.         initialize();  

25.     }  

26.   

27.     virtual ~AbstractCache()  

28.     {  

29.         uninitialize();  

30.     }  

31.   

32.         // ………..  

33.   

34. protected:  

35.     mutable FIFOEvent > IsValid;  

36.     mutable FIFOEvent           Replace;  

37.   

38.     void initialize()  

39.         /// Sets up event registration.  

40.     {  

41.         Add     += Delegateconst KeyValueArgs >(&_strategy, &TStrategy::onAdd);  

42.         Update  += Delegateconst KeyValueArgs >(&_strategy, &TStrategy::onUpdate);  

43.         Remove  += Delegateconst TKey>(&_strategy, &TStrategy::onRemove);  

44.         Get     += Delegateconst TKey>(&_strategy, &TStrategy::onGet);  

45.         Clear   += Delegateconst EventArgs>(&_strategy, &TStrategy::onClear);  

46.         IsValid += Delegate >(&_strategy, &TStrategy::onIsValid);  

47.         Replace += Delegate(&_strategy, &TStrategy::onReplace);  

48.     }  

49.   

50.     void uninitialize()  

51.         /// Reverts event registration.  

52.     {  

53.         Add     -= Delegateconst KeyValueArgs >(&_strategy, &TStrategy::onAdd );  

54.         Update  -= Delegateconst KeyValueArgs >(&_strategy, &TStrategy::onUpdate);  

55.         Remove  -= Delegateconst TKey>(&_strategy, &TStrategy::onRemove);  

56.         Get     -= Delegateconst TKey>(&_strategy, &TStrategy::onGet);  

57.         Clear   -= Delegateconst EventArgs>(&_strategy, &TStrategy::onClear);  

58.         IsValid -= Delegate >(&_strategy, &TStrategy::onIsValid);  

59.         Replace -= Delegate(&_strategy, &TStrategy::onReplace);  

60.     }  

61.   

62.     void doAdd(const TKey& key, const TValue& val)  

63.         /// Adds the key value pair to the cache.  

64.         /// If for the key already an entry exists, it will be overwritten.  

65.     {  

66.         Iterator it = _data.find(key);  

67.         doRemove(it);  

68.   

69.   

70.         KeyValueArgs args(key, val);  

71.         Add.notify(this, args);  

72.         _data.insert(std::make_pair(key, SharedPtr(new TValue(val))));  

73.           

74.         doReplace();  

75.     }  

76.   

77.     void doAdd(const TKey& key, SharedPtr& val)  

78.         /// Adds the key value pair to the cache.  

79.         /// If for the key already an entry exists, it will be overwritten.  

80.     {  

81.         Iterator it = _data.find(key);  

82.         doRemove(it);  

83.   

84.   

85.         KeyValueArgs args(key, *val);  

86.         Add.notify(this, args);  

87.         _data.insert(std::make_pair(key, val));  

88.           

89.         doReplace();  

90.     }  

91.   

92.     void doUpdate(const TKey& key, const TValue& val)  

93.         /// Adds the key value pair to the cache.  

94.         /// If for the key already an entry exists, it will be overwritten.  

95.     {  

96.         KeyValueArgs args(key, val);  

97.         Iterator it = _data.find(key);  

98.         if (it == _data.end())  

99.         {  

100.             Add.notify(this, args);  

101.             _data.insert(std::make_pair(key, SharedPtr(new TValue(val))));  

102.         }  

103.         else  

104.         {  

105.             Update.notify(this, args);  

106.             it->second = SharedPtr(new TValue(val));  

107.         }  

108.           

109.         doReplace();  

110.     }  

111.   

112.     void doUpdate(const TKey& key, SharedPtr& val)  

113.         /// Adds the key value pair to the cache.  

114.         /// If for the key already an entry exists, it will be overwritten.  

115.     {  

116.         KeyValueArgs args(key, *val);  

117.         Iterator it = _data.find(key);  

118.         if (it == _data.end())  

119.         {  

120.             Add.notify(this, args);  

121.             _data.insert(std::make_pair(key, val));  

122.         }  

123.         else  

124.         {  

125.             Update.notify(this, args);  

126.             it->second = val;  

127.         }  

128.           

129.         doReplace();  

130.     }  

131.   

132.     void doRemove(Iterator it)   

133.         /// Removes an entry from the cache. If the entry is not found  

134.         /// the remove is ignored.  

135.     {  

136.         if (it != _data.end())  

137.         {  

138.             Remove.notify(this, it->first);  

139.             _data.erase(it);  

140.         }  

141.     }  

142.   

143.     bool doHas(const TKey& key) const  

144.         /// Returns true if the cache contains a value for the key  

145.     {  

146.         // ask the strategy if the key is valid  

147.         ConstIterator it = _data.find(key);  

148.         bool result = false;  

149.   

150.   

151.         if (it != _data.end())  

152.         {  

153.             ValidArgs args(key);  

154.             IsValid.notify(this, args);  

155.             result = args.isValid();  

156.         }  

157.   

158.         return result;  

159.     }  

160.   

161.     SharedPtr doGet(const TKey& key)   

162.         /// Returns a SharedPtr of the cache entry, returns 0 if for  

163.         /// the key no value was found  

164.     {  

165.         Iterator it = _data.find(key);  

166.         SharedPtr result;  

167.   

168.         if (it != _data.end())  

169.         {     

170.             // inform all strategies that a read-access to an element happens  

171.             Get.notify(this, key);  

172.             // ask all strategies if the key is valid  

173.             ValidArgs args(key);  

174.             IsValid.notify(this, args);  

175.   

176.             if (!args.isValid())  

177.             {  

178.                 doRemove(it);  

179.             }  

180.             else  

181.             {  

182.                 result = it->second;  

183.             }  

184.         }  

185.   

186.         return result;  

187.     }  

188.   

189.     void doClear()  

190.     {  

191.         static EventArgs _emptyArgs;  

192.         Clear.notify(this, _emptyArgs);  

193.         _data.clear();  

194.     }  

195.   

196.     void doReplace()  

197.     {  

198.         std::set delMe;  

199.         Replace.notify(this, delMe);  

200.         // delMe contains the to be removed elements  

201.         typename std::set::const_iterator it    = delMe.begin();  

202.         typename std::set::const_iterator endIt = delMe.end();  

203.   

204.         for (; it != endIt; ++it)  

205.         {  

206.             Iterator itH = _data.find(*it);  

207.             doRemove(itH);  

208.         }  

209.     }  

210.   

211.     TStrategy          _strategy;  

212.     mutable DataHolder _data;  

213.     mutable TMutex  _mutex;  

214.   

215. private:  

216.     // ….  

217. };  

        从上面的定义中，可以看到AbstractCache是一个value的容器，采用map保存数据，

[cpp] view plaincopy

1. mutable std::map > _data;  

        另外AbstractCache中还定义了一个TStrategy对象，

[cpp] view plaincopy

1. TStrategy          _strategy;  

        并且在AbstractCache的initialize()函数中，把Cache的一些函数操作委托给TStrategy对象。其函数操作接口为：
        1. Add : 向容器中添加元素
        2. Update : 更新容器中元素
        3. Remove : 删除容器中元素
        4. Get : 获取容器中元素
        5. Clear : 清除容器中所有元素
        6. IsValid: 容器中是否某元素
        7. Replace: 按照策略从strategy中获取过期元素，并从Cache和Strategy中同时删除。将触发一系列的Remove函数。

        这几个操作中最复杂的是Add操作，其中包括了Remove、Insert和Replace操作。

[cpp] view plaincopy

1. void doAdd(const TKey& key, SharedPtr& val)  

2.     /// Adds the key value pair to the cache.  

3.     /// If for the key already an entry exists, it will be overwritten.  

4. {  

5.     Iterator it = _data.find(key);  

6.     doRemove(it);  

7.   

8.   

9.     KeyValueArgs args(key, *val);  

10.     Add.notify(this, args);  

11.     _data.insert(std::make_pair(key, val));  

12.           

13.     doReplace();  

14. }  

        而Replace操作可被Add、Update、Get操作触发。这是因为Cache并不是一个主动对象(POCO C++库学习和分析 -- 线程（四）)，不会自动的把元素标志为失效，需要外界也就是调用方触发进行。

        在Cache类中另外一个值得注意的地方是，保存的是TValue的SharedPtr。之所以这么设计，是为了线程安全，由于replace操作可能被多个线程调用，所以解决的方法，要么是返回TValue的SharedPtr，要么是返回TValue的拷贝。同拷贝方法相比，SharedPtr的方法要更加廉价。

2.2 Strategy类

       Strategy类完成了对_data中保存的pair中key的排序工作。每个Strategy中都存在一个key的容器，其中LRUStrategy中是std::list，ExpireStrategy、UniqueAccessExpireStrategy、UniqueExpireStrategy中是std::multimap。

       对于LRU策略，这么设计我是可以理解的。每次访问都会使key被重置于list的最前端。为了实现对list快速访问，增加一个std::map容器，每次对list容器进行插入操作时，把插入位的itorator保存入map中，这样对于list的访问效率可以从O(n)变成O(log(n)),因为不需要遍历了。下面是相关的代码：

[cpp] view plaincopy

1. void onReplace(const void*, std::set& elemsToRemove)  

2. {  

3.     // Note: replace only informs the cache which elements  

4.     // it would like to remove!  

5.     // it does not remove them on its own!  

6.     std::size_t curSize = _keyIndex.size();  

7.   

8.     if (curSize < _size)  

9.     {  

10.         return;  

11.     }  

12.   

13.     std::size_t diff = curSize - _size;  

14.     Iterator it = --_keys.end(); //--keys can never be invoked on an empty list due to the minSize==1 requirement of LRU  

15.     std::size_t i = 0;  

16.   

17.     while (i++ < diff)   

18.     {  

19.         elemsToRemove.insert(*it);  

20.         if (it != _keys.begin())  

21.         {  

22.             --it;  

23.         }  

24.     }  

25. }  

        LRUStrategy的replace操作是，只在curSize超过设定的访问上限_size时触发，把list容器中排在末尾的(curSize-_size)个元素标志为失效。

        而对于Time base expired策略，还如此设计，我觉得不太合适。在时间策略的strategy类中，存在着两个容器，一个是std::map，另外一个是std::multimap。进行插入操作时，代码为：

[cpp] view plaincopy

1. void onAdd(const void*, const KeyValueArgs & args)  

2. {  

3.     Timestamp now;  

4.     IndexIterator it = _keyIndex.insert(typename TimeIndex::value_type(now, args.key()));  

5.     std::pair<Iterator, bool> stat = _keys.insert(typename Keys::value_type(args.key(), it));  

6.     if (!stat.second)  

7.     {  

8.         _keyIndex.erase(stat.first->second);  

9.         stat.first->second = it;  

10.     }  

11. }  

        可以看到map容器中保存的是multimap中pair对的itorator。其replace操作如下：

[cpp] view plaincopy

1. void onReplace(const void*, std::set& elemsToRemove)  

2. {  

3.     // Note: replace only informs the cache which elements  

4.     // it would like to remove!  

5.     // it does not remove them on its own!  

6.     IndexIterator it = _keyIndex.begin();  

7.     while (it != _keyIndex.end() && it->first.isElapsed(_expireTime))  

8.     {  

9.         elemsToRemove.insert(it->second);  

10.         ++it;  

11.     }  

12. }  

        可以看到这是对multimap的遍历，效率为O(n)。

        如果这样的话，我觉得完全可以把std::map和std::multimap合二为一，定义成为std::map，replace的操作仍然采用遍历，效率为O(n).
        对于基于时间的策略，O(n)的效率可能不能接受。我觉得可能的解决方法有两种。第一，把Cache变成主动对象，内部定期的收集失效元素，而不由外部触发。这样虽然并没有提高replace操作效率，但把replace操作和外部接口的add等操作分开了。外部调用接口的效率提高了。第二，在内部实现多个map容器，分组管理不同过期时间的对象。

3. 开销

        Poco中的Cache类比std::map要慢，其中开销最大的操作为add操作。采用Time Expire策略的Cache要比采用LRU策略的Cache更慢。并且由于Cache类引入了SharePtr和Strategy，其空间花费也要大于std::map。所以在没有必要使用Cache的情况下，还是使用map较好。

4. 例子

        下面是Cache的一个示例：

[cpp] view plaincopy

1. #include "Poco/LRUCache.h"  

2. int main()  

3. {  

4.     Poco::LRUCache<int, std::string> myCache(3);  

5.     myCache.add(1, "Lousy"); // |-1-| -> first elem is the most popular one  

6.     Poco::SharedPtr ptrElem = myCache.get(1); // |-1-|  

7.     myCache.add(2, "Morning"); // |-2-1-|  

8.     myCache.add(3, "USA"); // |-3-2-1-|  

9.     // now get rid of the most unpopular entry: "Lousy"  

10.     myCache.add(4, "Good"); // |-4-3-2-|  

11.     poco_assert (*ptrElem == "Lousy"); // content of ptrElem is still valid  

12.     ptrElem = myCache.get(2); // |-2-4-3-|  

13.     // replace the morning entry with evening  

14.     myCache.add(2, "Evening"); // 2 Events: Remove followed by Add  

15. }  

POCO C++库学习和分析 -- 字符编码

1. 字符编码

1.1 字符编码的概念

        字符编码可以理解为在计算机上语言符号和二比特数之间的映射。不同的编码方式对应着不同映射方法，对于映射集的双方而言，用一种映射方法下，映射关系是一一对应的。由于语言的基本符号是有限的，所以作为映射的双方，映射集也是有限的。下面这段概念的介绍来自于文章《字符编码：Unicode/UTF-8/UTF-16/UCS/Endian/BMP/BOM》、《C++字符串完全指引(ZT)》、《字符编码笔记：ASCII，Unicode和UTF-8》，并混杂了一些自己的理解。

1. ASCII码 

        对于英文字母而言，语言的符号是26个字母，因此在上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码，一直沿用至今。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。 

2. 非ASCII编码 

        英语用128个符号编码就够了，但是用来表示其他语言，128个符号是不够的。比如，在法语中，字母上方有注音符号，它就无法用ASCII码表示。于是，一些欧洲国家就决定，利用字节中闲置的最高位编入新的符号。比如，法语中的é的编码为130（二进制10000010）。这样一来，这些欧洲国家使用的编码体系，可以表示最多256个符号。 
        但是，这里又出现了新的问题。不同的国家有不同的字母，因此，哪怕它们都使用256个符号的编码方式，代表的字母却不一样。比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel (ג)，在俄语编码中又会代表另一个符号。但是不管怎样，所有这些编码方式中，0—127表示的符号是一样的，不一样的只是128—255的这一段。 
        至于亚洲国家的文字，使用的符号就更多了，汉字就多达10万左右。一个字节只能表示256种符号，肯定是不够的，就必须使用多个字节表达一个符号。比如，简体中文常见的编码方式是GB2312，使用两个字节表示一个汉字，所以理论上最多可以表示256×256=65536个符号。中文编码的问题需要专文讨论，这篇笔记不涉及。这里只指出，虽然都是用多个字节表示一个符号，但是GB类的汉字编码与后文的Unicode和UTF-8是毫无关系的。 

3. 各自定义非ASCII编码的问题

        由于各国都制定了自己的兼容ascii编码规范,就是各种ANSI码,比如我国的gb2312，用两个扩展ascii字符来表示一个中文。这带来了一个新问题，这些ansi码无法同时存在,因为它们的定义互相重叠,要自由使用不同语言就必须有一个新编码,为各种文字统一分配编码。 

4. 微软的解决方案

        微软为了解决这一问题，提出了一个自己的解决方案。windows上的MBCS方法，在 MBCS 下，字符被编码为单字节或双字节。在双字节字符中，第一个字节（即前导字节）表示它和下一个字节将被解释为一个字符。第一个字节来自留作前导字节的代码范围。哪个范围的字节可以用作前导字节取决于所使用的代码页。例如，日文代码页 932 使用 0x81 到 0x9F 范围内的字节作为前导字节，而朝鲜语代码页 949 则使用其他范围的字节。

5. 另一种解决方案Unicode

        虽然微软提了自己的方案，其他人也没闲着。为了解决这一问题。国际标准化组织（ISO）想出了一个办法，这个办法其实和微软也类似。即存在有一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，那么乱码问题就会消失。这就是Unicode，就像它的名字都表示的，这是一种所有符号的编码。 
        Unicode是一种字符编码方法，它是由国际组织设计，可以容纳全世界所有语言文字的编码方案。Unicode的学名是”UniversalMultiple-Octet Coded Character Set
”，简称为UCS。UCS可以看作是”Unicode Character Set”的缩写。 

       Unicode现在的规模可以容纳100多万个符号。每个符号的编码都不一样，比如，U+0639表示阿拉伯字母Ain，U+0041表示英语的大写字母A，U+4E25表示汉字“严”。具体的符号对应表，可以查询unicode.org，或者专门的汉字对应表。 
        根据维基百科的记载：历史上存在两个试图独立设计Unicode的组织，即国际标准化组织（ISO）和一个软件制造商的协会（unicode.org）。ISO开发了ISO 10646项目，Unicode协会开发了Unicode项目。 在1991年前后，双方都认识到世界不需要两个不兼容的字符集。于是它们开始合并双方的工作成果，并为创立一个单一编码表而协同工作。从Unicode2.0开始，Unicode项目采用了与ISO 10646-1相同的字库和字码。 目前两个项目仍都存在，并独立地公布各自的标准。Unicode协会现在的最新版本是2005年的Unicode 4.1.0。ISO的最新标准是10646-3:2003。 

6. UCS-2、UCS-4、BMP 

        UCS有两种格式：UCS-2和UCS-4。顾名思义，UCS-2就是用两个字节编码，UCS-4就是用4个字节（实际上只用了31位，最高位必须为0）编码。下面让我们做一些简单的数学游戏： 
        UCS-2有2^16=65536个码位，UCS-4有2^31=2147483648个码位。 
        UCS-4根据最高位为0的最高字节分成2^7=128个group。每个group再根据次高字节分为256个plane。每个plane根据第3个字节分为256行 (rows)，每行包含256个cells。当然同一行的cells只是最后一个字节不同，其余都相同。 
        group 0的plane 0被称作BasicMultilingual Plane, 即BMP。或者说UCS-4中，高两个字节为0的码位被称作BMP。 
        将UCS-4的BMP去掉前面的两个零字节就得到了UCS-2。在UCS-2的两个字节前加上两个零字节，就得到了UCS-4的BMP。而目前的UCS-4规范中还没有任何字符被分配在BMP之外。
        由于即使是老UCS-2,也可以表示2^16=65535个字符,基本上可以容纳所有常用各国字符,所以目前各国基本都使用UCS-2。  

7. Unicode的问题 

        值得注意的是，Unicode只是一个符号集，它只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储。 
        比如，汉字“严”的unicode是十六进制数4E25，转换成二进制数足足有15位（100111000100101），也就是说这个符号的表示至少需要2个字节。表示其他更大的符号，可能需要3个字节或者4个字节，甚至更多。 
        这里就有两个严重的问题，第一个问题是，如何才能区别unicode和ascii？计算机怎么知道三个字节表示一个符号，而不是分别表示三个符号呢？第二个问题是，我们已经知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储来说是极大的浪费，文本文件的大小会因此大出二三倍，这是无法接受的。 
        它们造成的结果是：1）出现了unicode的多种存储方式，也就是说有许多种不同的二进制格式，可以用来表示unicode。2）unicode在很长一段时间内无法推广，直到互联网的出现。 
        怎样存储和传输这些编码，是由UTF(UCS TransformationFormat)规范规定的，常见的UTF规范包括UTF-8、UTF-7、UTF-16、UTF-32。

8. UTF编码

        UTF(UCS Transformation Format)规范设计时考虑了一些现实问题。即在UCS定义之前，已经存在大量的ASCII程序。新定义的UCS的表示方法必须兼容原始的ascii程序和方法。
        这个问题也可以表示为，Unicode使用2个字节表示一个字符,ascii使用1个字节,在很多方面产生了冲突，以前处理ascii的方法都必须重写。而且C语言用\0作为字符串结束标志,但Unicode中很多字符都含\0,C语言的字符串函数也无法正常处理Unicode。为了把unicode投入实用,出现了UTF,最常见的是UTF-8、UTF-16和UTF-32。

        其中UTF-16和Unicode本身的编码是一致的,UTF-32和UCS-4也是相同的，但最重要的是UTF-8编码方式。(UTF-32中字符的数量为2^32，也就是说用一个4 byte的int值可以表示一个人类字符。一个int值既然可以可以表示所有UCS-4中的字符，当然也可以表示UCS-2中对应的所有字符)。那为什么会出现UTF-8编码方式呢。UTF8是一种变长的编码,它的字节数是不固定的,使用第一个字节确定字节数。第一个字节首为0即一个字节,110即2字节,1110即3字节,字符后续字节都用10开始,这样不会混淆且单字节英文字符可仍用ASCII编码。理论上UTF-8最大可以用6字节表示一个字符,但Unicode目前没有用大于0xffff的字符,实际UTF-8最多使用了3个字节。 

        UTF-8就是以8位为单元对UCS进行编码。从UCS-2到UTF-8的编码方式如下： 

UCS-2编码(16进制)

bit数

UTF-8 字节流(二进制)

byte数

备注

0000 0000 ~

0000 007F

0~7

0XXX XXXX

1

​

0000 0080 ~

0000 07FF

8~11

110X XXXX

10XX XXXX

2

​

0000 0800 ~

0000 FFFF

12~16

1110 XXXX

10XX XXXX

10XX XXXX

3

基本定义范围：0~FFFF

0001 0000 ~

001F FFFF

17~21

1111 0XXX

10XX XXXX

10XX XXXX

10XX XXXX

4

Unicode6.1定义范围：0~10 FFFF

0020 0000 ~

03FF FFFF

22~26

1111 10XX

10XX XXXX

10XX XXXX

10XX XXXX

10XX XXXX

5

​

0400 0000 ~

7FFF FFFF

27~31

1111 110X

10XX XXXX

10XX XXXX

10XX XXXX

10XX XXXX

10XX XXXX

6

​

表一，UCS-2到UTF-8的编码方式表

        例如“汉”字的Unicode编码是6C49。6C49在0800-FFFF之间，所以肯定要用3字节模板了：1110xxxx10xxxxxx 10xxxxxx。将6C49写成二进制是：011011000100 1001，用这个比特流依次代替模板中的x，得到：111001101011000110001001，即E6 B1 89。 
        读者可以用记事本测试一下我们的编码是否正确。 
        UTF-16以16位为单元对UCS进行编码。对于小于0×10000的UCS码，UTF-16编码就等于UCS码对应的16位无符号整数。对于不小于0×10000的UCS码，定义了一个算法。不过由于实际使用的UCS2，或者UCS4的BMP必然小于0×10000，所以就目前而言，可以认为UTF-16和UCS-2基本相同。但UCS-2只是一个编码方案，UTF-16却要用于实际的传输，所以就不得不考虑字节序的问题。 

        看到这里，读者要问了，对于汉字来说，使用UTF-8来说，存储的字节数"E6 B189"要比直接使用Unicode编码"6C49"还多啊。没办法，对于汉字来说，确实增多了。但对于英语系国家来说，UTF-8比Unicode省了。谁叫计算机是别们发明的呢，总是有点特权的。

9. Little endian和Big endian

        上一节已经提到，Unicode码可以采用UCS-2格式直接存储。以汉字”严“为例，Unicode码是4E25，需要用两个字节存储，一个字节是4E，另一个字节是25。存储的时候，4E在前，25在后，就是Big endian方式；25在前，4E在后，就是Little endian方式。 
        这两个古怪的名称来自英国作家斯威夫特的《格列佛游记》。在该书中，小人国里爆发了内战，战争起因是人们争论，吃鸡蛋时究竟是从大头(Big-Endian)敲开还是从小头(Little-Endian)敲开。为了这件事情，前后爆发了六次战争，一个皇帝送了命，另一个皇帝丢了王位。 因此，第一个字节在前，就是”大头方式“（Big endian），第二个字节在前就是”小头方式“（Little endian）。 那么很自然的，就会出现一个问题：计算机怎么知道某一个文件到底采用哪一种方式编码？ 
        Unicode规范中定义，每一个文件的最前面分别加入一个表示编码顺序的字符，这个字符的名字叫做”零宽度非换行空格“（ZERO WIDTH NO-BREAK SPACE），用FEFF表示。这正好是两个字节，而且FF比FE大1。 
        如果一个文本文件的头两个字节是FEFF，就表示该文件采用大头方式；如果头两个字节是FF FE，就表示该文件采用小头方式。 

2. Poco中字符编码

2.1 编码的介绍

        有了上面的基本概念，对于Poco中的字符编码，理解就简单了。在Poco中存在ASCII，Latin1，Latin9，Windows1252，UTF16，UTF8编码。其中ASCII对应的字符集大小为128；Latin1和Latin9表达的对象为拉丁语，其对应的字符集大小为256；Windows1252对应的字符集大小也为256；UTF16，UTF8表达的字符集对象为UCS2，大小为2^32。下面把涉及的这几种编码说的详细一点：

       Latin1：Latin1是ISO-8859-1的别名，有些环境下写作Latin-1。

　　ISO-8859-1
　　ISO-8859-1编码是单字节编码，向下兼容ASCII，其编码范围是0x00-0xFF，0x00-0x7F之间完全和ASCII一致，0x80-0x9F之间是控制字符，0xA0-0xFF之间是文字符号。
　　ISO-8859-1收录的字符除ASCII收录的字符外，还包括西欧语言、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。欧元符号出现的比较晚，没有被收录在ISO-8859-1当中。
　　因为ISO-8859-1编码范围使用了单字节内的所有空间，在支持ISO-8859-1的系统中传输和存储其他任何编码的字节流都不会被抛弃。换言之，把其他任何编码的字节流当作ISO-8859-1编码看待都没有问题。这是个很重要的特性，MySQL数据库默认编码是Latin1就是利用了这个特性。ASCII编码是一个7位的容器，ISO-8859-1编码是一个8位的容器。
       Latin9：

       看代码的话，和Latin1的区别在于，Latin1用2个字节去表示文字符号，而Latin9用4个字节表示文字符号。

       UTF8：

       UTF-8是UNICODE的一种变长字符编码又称万国码，由KenThompson于1992年创建。现在已经标准化为RFC 3629。UTF-8用1到6个字节编码UNICODE字符。用在网页上可以同一页面显示中文简体繁体及其它语言（如日文，韩文）。UTF-8编码的优点，UTF-8编码可以通过屏蔽位和移位操作快速读写。字符串比较时strcmp()和wcscmp()的返回结果相同，因此使排序变得更加容易。字节FF和FE在UTF-8编码中永远不会出现，因此他们可以用来表明UTF-16或UTF-32文本（见BOM） UTF-8 是字节顺序无关的。它的字节顺序在所有系统中都是一样的，因此它实际上并不需要BOM。UTF-8编码的缺点，无法从UNICODE字符数判断出UTF-8文本的字节数，因为UTF-8是一种变长编码它需要用2个字节编码那些用扩展ASCII字符集只需1个字节的字符 ISO Latin-1 是UNICODE的子集，但不是UTF-8的子集 8位字符的UTF-8编码会被email网关过滤，因为internet信息最初设计为7位ASCII码。因此产生了UTF-7编码。 UTF-8 在它的表示中使用值100xxxxx的几率超过50%， 而现存的实现如ISO 2022， 4873， 6429， 和8859系统，会把它错认为是C1 控制码。因此产生了UTF-7.5编码。

       UTF16：

       UTF-16是Unicode的其中一个使用方式。 UTF是 Unicode Translation Format，即把Unicode转做某种格式的意思。它定义于ISO/IEC 10646-1的附录Q，而RFC2781也定义了相似的做法。在Unicode基本多文种平面定义的字符（无论是拉丁字母、汉字或其他文字或符号），一律使用2字节储存。而在辅助平面定义的字符，会以代理对（surrogate pair）的形式，以两个2字节的值来储存。UTF-16比起UTF-8，好处在于大部分字符都以固定长度的字节 (2字节) 储存，但UTF-16却无法兼容于ASCII编码。c#中默认的就是UTF-16，所以在处理c#字符串的时候只能是byte,stream等方式去处理。

       UTF-32：
       UTF-32 (或 UCS-4)是一种将Unicode字符编码的协定，对每一个Unicode码位使用恰好32位元。其它的Unicode transformation formats则使用不定长度编码。因为UTF-32对每个字符都使用4字节，就空间而言，是非常没有效率的。特别地，非基本多文种平面的字符在大部分文件中通常很罕见，以致于它们通常被认为不存在占用空间大小的讨论，使得UTF-32通常会是其它编码的二到四倍。虽然每一个码位使用固定长定的字节看似方便，它并不如其它Unicode编码使用得广泛。与UTF-8及UTF-16相比，它有点更容易遭截断。
       

2.2 字符原集和表示之间的转换类

       Poco中的编码类都从TextEncoding类继承。TextEncoding类的接口定义如下：

[cpp] view plaincopy

1. class Foundation_API TextEncoding  

2. {  

3. public:  

4.     typedef SharedPtr Ptr;  

5.       

6.     enum  

7.     {  

8.         MAX_SEQUENCE_LENGTH = 6 /// The maximum character byte sequence length supported.  

9.     };  

10.       

11.     typedef int CharacterMap[256];  

12.   

13.   

14.     virtual ~TextEncoding();  

15.   

16.     virtual const char* canonicalName() const = 0;  

17.   

18.     virtual bool isA(const std::string& encodingName) const = 0;  

19.               

20.                // ……..  

21.           

22.     virtual int convert(const unsigned char* bytes) const;  

23.   

24.     virtual int queryConvert(const unsigned char* bytes, int length) const;  

25.   

26.     virtual int sequenceLength(const unsigned char* bytes, int length) const;  

27.   

28.     virtual int convert(int ch, unsigned char* bytes, int length) const;  

29.   

30.   

31.                // ….  

32.           

33. protected:  

34.     static TextEncodingManager& manager();  

35.         /// Returns the TextEncodingManager.  

36. };  

       我们可以把要表示的字符集称为字符原集，如UCS2，UCS4，它规定了字符集中存在哪些字符，并把每一个字符和数字之间建立一一映射关系。由于字符原集是个有穷集合，一个int值(2^32)足以表示其定义。一个字符的原集在被应用到计算机中时，会存在多种表示方式，如UCS2可以表示为UTF8，UTF16，我们称为原集的表示。

      TextEncoding中下面两个函数，用来把”原集的表示“转换为原集字符(一个int值)。

[cpp] view plaincopy

1. int convert(const unsigned char* bytes) const;  

2. int queryConvert(const unsigned char* bytes, int length) const;  

       而下面这个函数则用来把原集字符(一个int值)转换成”原集的表示“。

[cpp] view plaincopy

1. int convert(int ch, unsigned char* bytes, int length) const;  

      拿UTF8Encoding类来举例，其原集为UCS2，表示方法是UTF8。

      ”原集字符“转成”UTF8“表示，其函数实现如下：

[cpp] view plaincopy

1. int UTF8Encoding::convert(int ch, unsigned char* bytes, int length) const  

2. {  

3.     if (ch <= 0x7F)  

4.     {  

5.         if (bytes && length >= 1)  

6.             *bytes = (unsigned char) ch;  

7.         return 1;  

8.     }  

9.     else if (ch <= 0x7FF)  

10.     {  

11.         if (bytes && length >= 2)  

12.         {  

13.             *bytes++ = (unsigned char) (((ch >> 6) & 0x1F) | 0xC0);  

14.             *bytes   = (unsigned char) ((ch & 0x3F) | 0x80);  

15.         }  

16.         return 2;  

17.     }  

18.     else if (ch <= 0xFFFF)  

19.     {  

20.         if (bytes && length >= 3)  

21.         {  

22.             *bytes++ = (unsigned char) (((ch >> 12) & 0x0F) | 0xE0);  

23.             *bytes++ = (unsigned char) (((ch >> 6) & 0x3F) | 0x80);  

24.             *bytes   = (unsigned char) ((ch & 0x3F) | 0x80);  

25.         }  

26.         return 3;  

27.     }  

28.     else if (ch <= 0x10FFFF)  

29.     {  

30.         if (bytes && length >= 4)  

31.         {  

32.             *bytes++ = (unsigned char) (((ch >> 18) & 0x07) | 0xF0);  

33.             *bytes++ = (unsigned char) (((ch >> 12) & 0x3F) | 0x80);  

34.             *bytes++ = (unsigned char) (((ch >> 6) & 0x3F) | 0x80);  

35.             *bytes   = (unsigned char) ((ch & 0x3F) | 0x80);  

36.         }  

37.         return 4;  

38.     }  

39.     else return 0;  

40. }  

     ”UTF8“表示转成”原集字符“，其函数实现如下：

[cpp] view plaincopy

1. int UTF8Encoding::convert(const unsigned char* bytes) const  

2. {  

3.     int n = _charMap[*bytes];  

4.     int uc;  

5.       

6.     switch (n)  

7.     {  

8.     case -6:  

9.     case -5:  

10.     case -1:  

11.         return -1;  

12.     case -4:   

13.     case -3:   

14.     case -2:  

15.         if (!isLegal(bytes, -n)) return -1;  

16.         uc = *bytes & ((0x07 << (n + 4)) | 0x03);  

17.         break;  

18.     default:  

19.         return n;  

20.     }  

21.   

22.     while (n++ < -1)   

23.     {     

24.         uc <<= 6;  

25.         uc |= (*++bytes & 0x3F);  

26.     }  

27.     return uc;  

28. }  

     这两段代码就是上面的表一《UCS-2到UTF-8的编码方式表》的代码表现。其他的编码也类似。在UTF16Encoding类中，由于UCS2和UTF16表示是一致的，所以不存在转换关系，但有bigendian和litterendian实现问题。在ASCIIEncoding类中，原集和其表现也一致，所以也不存在转换问题。

     下面是  TextEncoding和其相关类的类图：

     TextEncodingManager是TextEncoding类的工厂类，创建了ASCIIEncoding、UTF16Encoding等编码对象。

2.3 字符集之间的转换

     不同字符集之间的转换，实际上是不同字符原集的不同表示之间的转换。如果两个表示方法的原集相同，转换起来自然方便一些。Poco中提供了UnicodeConverter类用于UTF8和UTF16之间的转换。其定义如下：

[cpp] view plaincopy

1. class Foundation_API UnicodeConverter  

2. {  

3. public:  

4.     static void toUTF16(const std::string& utf8String, std::wstring& utf16String);  

5.         /// Converts the given UTF-8 encoded string into an UTF-16 encoded wstring.  

6.   

7.     static void toUTF16(const char* utf8String, int length, std::wstring& utf16String);   

8.         /// Converts the given UTF-8 encoded character sequence into an UTF-16 encoded string.  

9.   

10.     static void toUTF16(const char* utf8String, std::wstring& utf16String);   

11.         /// Converts the given zero-terminated UTF-8 encoded character sequence into an UTF-16 encoded wstring.  

12.   

13.     static void toUTF8(const std::wstring& utf16String, std::string& utf8String);  

14.         /// Converts the given UTF-16 encoded wstring into an UTF-8 encoded string.  

15.   

16.     static void toUTF8(const wchar_t* utf16String, int length, std::string& utf8String);  

17.         /// Converts the given zero-terminated UTF-16 encoded wide character sequence into an UTF-8 encoded wstring.  

18.   

19.     static void toUTF8(const wchar_t* utf16String, std::string& utf8String);  

20.         /// Converts the given UTF-16 encoded zero terminated character sequence into an UTF-8 encoded string.  

21. };  

     注意UTF-16用在C++中是用wtring存储的。虽然UTF-16对应着UCS2，内部存储时，一个short已经足够。但在Linux下默认是占4个字节，当然在用GCC编译时可以使用-fshort-wchar来强制使用2个字节，而在Windows上被定义为unsigned short。

     如果两个表示方法的原集不同，则要考虑转换方向问题。比如说中文字符在ASCII码中不存在，那么毫无疑问，把中文字符转换成ASCII码自然无意义，这个方向的转换注定要失败。在Poco中，上述字符集之间的转换是用类TextConverter来实现的。下面是它的定义：

[cpp] view plaincopy

1. class Foundation_API TextConverter  

2.     /// A TextConverter converts strings from one encoding  

3.     /// into another.  

4. {  

5. public:  

6.     typedef int (*Transform)(int);  

7.         /// Transform function for convert.  

8.           

9.     TextConverter(const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar = '?');  

10.         /// Creates the TextConverter. The encoding objects must not be deleted while the  

11.         /// TextConverter is in use.  

12.   

13.     ~TextConverter();  

14.         /// Destroys the TextConverter.  

15.           

16.     int convert(const std::string& source, std::string& destination, Transform trans);  

17.         /// Converts the source string from inEncoding to outEncoding  

18.         /// and appends the result to destination. Every character is  

19.         /// passed to the transform function.  

20.         /// If a character cannot be represented in outEncoding, defaultChar  

21.         /// is used instead.  

22.         /// Returns the number of encoding errors (invalid byte sequences  

23.         /// in source).  

24.   

25.     int convert(const void* source, int length, std::string& destination, Transform trans);  

26.         /// Converts the source buffer from inEncoding to outEncoding  

27.         /// and appends the result to destination. Every character is  

28.         /// passed to the transform function.  

29.         /// If a character cannot be represented in outEncoding, defaultChar  

30.         /// is used instead.  

31.         /// Returns the number of encoding errors (invalid byte sequences  

32.         /// in source).  

33.   

34.     int convert(const std::string& source, std::string& destination);  

35.         /// Converts the source string from inEncoding to outEncoding  

36.         /// and appends the result to destination.  

37.         /// If a character cannot be represented in outEncoding, defaultChar  

38.         /// is used instead.  

39.         /// Returns the number of encoding errors (invalid byte sequences  

40.         /// in source).  

41.   

42.     int convert(const void* source, int length, std::string& destination);  

43.         /// Converts the source buffer from inEncoding to outEncoding  

44.         /// and appends the result to destination.  

45.         /// If a character cannot be represented in outEncoding, defaultChar  

46.         /// is used instead.  

47.         /// Returns the number of encoding errors (invalid byte sequences  

48.         /// in source).  

49.   

50. private:  

51.     TextConverter();  

52.     TextConverter(const TextConverter&);  

53.     TextConverter& operator = (const TextConverter&);  

54.   

55.     const TextEncoding& _inEncoding;  

56.     const TextEncoding& _outEncoding;  

57.     int                 _defaultChar;  

58. };  

       如果要在流输出之前，进行字符集转换，Poco还提供了类StreamConverterBuf。其定义为：

[cpp] view plaincopy

1. class Foundation_API StreamConverterBuf: public UnbufferedStreamBuf  

2.     /// A StreamConverter converts streams from one encoding (inEncoding)  

3.     /// into another (outEncoding).  

4.     /// If a character cannot be represented in outEncoding, defaultChar  

5.     /// is used instead.  

6.     /// If a byte sequence is not valid in inEncoding, defaultChar is used  

7.     /// instead and the encoding error count is incremented.  

8. {  

9. public:  

10.     StreamConverterBuf(std::istream& istr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar = '?');  

11.         /// Creates the StreamConverterBuf and connects it  

12.         /// to the given input stream.  

13.   

14.     StreamConverterBuf(std::ostream& ostr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar = '?');  

15.         /// Creates the StreamConverterBuf and connects it  

16.         /// to the given output stream.  

17.   

18.     ~StreamConverterBuf();  

19.         /// Destroys the StreamConverterBuf.  

20.   

21.     int errors() const;  

22.         /// Returns the number of encoding errors encountered.  

23.   

24. protected:  

25.     int readFromDevice();  

26.     int writeToDevice(char c);  

27.   

28. private:  

29.     std::istream*       _pIstr;  

30.     std::ostream*       _pOstr;  

31.     const TextEncoding& _inEncoding;  

32.     const TextEncoding& _outEncoding;  

33.     int                 _defaultChar;  

34.     unsigned char       _buffer[TextEncoding::MAX_SEQUENCE_LENGTH];  

35.     int                 _sequenceLength;  

36.     int                 _pos;  

37.     int                 _errors;  

38. };