在实际的boost signal中并没有直接的存储slot（boost signal库中有个slot类），而是存储了function（boost function类的对象）对象。而且为了方便控制signal与function之间的联系，引入了connection类，用来表示signal与function之间的联系。Connection的对象当然和一个function放在了一起。这样boost signal提供了一个connection_slot_pair类来存储一个function与connection对。这样在boost signal中一个slot组的实际定义如下std::list< connection_slot_pair >。并且被重定义为group_list类型（typedef std::list<connection_slot_pair> group_list）。相应的在boost signal中map的实际定义如下std::map<stored_group, group_list, compare_type>，并且被重定义为slot_container_type（typedef std::map<stored_group, group_list, compare_type> slot_container_type）。将以上的这些东西组织到一个类中，以便于管理。这个类就是named_slot_map。Signal中真正用来管理slot的管理器。

         Named_slot_map的类数据成员如下定义（boost源码中的一部分，数据成员部分）

class BOOST_SIGNALS_DECL named_slot_map

{

public:

typedef named_slot_map_iterator iterator;//named_slot_map容器的迭代器

private:

typedef std::list<connection_slot_pair> group_list;//function connection对组类型

typedef std::map<stored_group, group_list, compare_type> slot_container_type;//容器类型

typedef slot_container_type::iterator group_iterator;//容器迭代器类型

typedef slot_container_type::const_iterator const_group_iterator;

slot_container_type groups;//定义一个用来管理function connection组的容器对象

group_iterator back;//容器的迭代器对象

};

         Named_slot_map也是一个容器。Stl的容器为了外界方便访问容器内数据单元，提供了迭代器。Named_slot_map也有自己的迭代器。这个迭代器就是named_slot_map_iterator类。Named_slot_map提供了以下方法来获得迭代器iterator begin()，iterator end()。Begin方法提供首迭代器，end方法提供尾迭代器。向容器中插入数据用insert。清除某个数据用而而然erase，清空容器中的所有数据用clear。

　　个人觉得在slot<>中的最有用处的函数。
void slot_base::create_connection()
{
 basic_connection* con = new basic_connection();

 {
  con->signal = static_cast<void*>(this);
  con->signal_data = 0;
  con->blocked_ = false ;
  con->signal_disconnect = &bound_object_destructed;
 }
 
 data->watch_bound_objects.reset(con);

 scoped_connection safe_connection(data->watch_bound_objects);

 for(std::vector<const trackable*>::iterator i = data->bound_objects.begin();
  i != data->bound_objects.end(); ++i)
 {
  BOOST_SIGNALS_NAMESPACE::detail::bound_object binding;
  (*i)->signal_connected(data->watch_bound_objects, binding);

  BOOST_SIGNALS_NAMESPACE::detail::auto_disconnect_bound_object disconnector(binding);

  con->bound_objects.push_back(binding);
  disconnector.release();
 }

 safe_connection.release();
 data->watch_bound_objects.set_controlling(true);
}

An non-nullary metafunction is invoked by instantiating the class template with particular template parameters (metafunction arguments);
一个非无参的原操作被一个有详细模板参数的模板类请求；
the result of the metafunction application is accessible through the instantiation's nested type typedef.
原操作应用的返回值是一个通过模板类实例可取的内嵌的类型定义。

All metafunction's arguments must be types (i.e. only type template parameters are allowed).
所有的原操作的参数必须是类型。

A metafunction can have a variable number of parameters.
一个原操作能有一个数量变化的参数

A nullary metafunction is represented as a (template) class with a nested type typename member.
一个无参数原操作被表现为有内嵌重命名类型的类

原操作的三种表达式（f是一个原操作）
1 f::type
2 f<>::type
3 f< a1,..,an >::type

Lambda Expression 构造和分配表达式

A Lambda Expression is a compile-time invocable entity in either of the following two forms:
一个构造和分配表达式是下面两个中的一个编译期调用单元

Metafunction Class
原操作类

Placeholder Expression
站位符表达式

Most of the MPL components accept either of those, and the concept gives us a consice way to describe these requirements.
大部分的MPL组件接收它们其中一个，

    template< typename Type >
    struct Holder
    {
        Type value_;
    };

    template< typename TypeSequeue, template< typename > class Unit >
    struct TypeConstract : public Unit< typename boost::mpl::front< TypeSequeue >::type >,
                           public TypeConstract< typename boost::mpl::pop_front< TypeSequeue >::type,
                                                 Unit >
    {
    };

    template< template< typename > class Unit >
    struct TypeConstract< boost::mpl::vector<>::type, Unit >
    {
    };