[c++]基于 boost 模板编程的缓冲池实现

这篇文章用来记录过去的一周中，使用 boost 和 template 模板编程来实现一个简单的缓冲区。
程序中主要有两个主要的类 : Cache , CachePool 
其中 CachePool 操纵的对象是需要缓存的实例，该实例既可以出自 class ，也可以是 struct。
Cache 的操作对象便是 CachePool ， 在 Cache 的内部首先根据需要来创建一个可以缓冲的类型列表，
将其定义为 CacheableTypes 类型。 CacheableTypes 本质上是 boost::mpl::vector < 多个类型名称>

然后根据 CacheableType 定义的 vector 作为头部创建以对象类型为索引的 map ，并将其定义为 CacheMap_t 变量
CacheMap_t 内部定义是这样的
CachMap  > 
CacheMap.value (pair) :  >
 
使用画图的方法简单表示出来就是这样:



编程环境 : vs2010

代码如下所示 
.hpp 文件中既可以写头文件中的内容，比如说类的声明，以及方法的定义，
也可以添加 .cpp 文件中的内容，比如说，在类的外面给出类中声明的方法的实现代码。

// SharedPtr.hpp

#ifndef SHARED_PTR_HPP__
#define SHARED_PTR_HPP__


#include <boost/shared_ptr.hpp>
template <typename T>
class sharedptr
{
public :
    typedef boost::shared_ptr<T> type ;
} ;


#endif

// CacheableTyeps.hpp

#ifndef CACHE_ABLE_TYPES_HPP__
#define CACHE_ABLES_TYPES_HPP__

#include <boost/mpl/vector.hpp>
#include <string>

class obj1
{
public :

    obj1( std::string name )
    {
        std::cout <<"create  "<< name << std::endl ;
        _name = name ;

    }

    void print ()
    {
        std::cout<<"print  " << _name <<std::endl ;
    }

public:
    std::string _name ;
} ;

class obj2
{
public :
    obj2( std::string n )
    {
        std::cout <<"create  "<<n << std::endl ;
        name = n ;
    }
    void print ()
    {
        std::cout <<"print  "<< name <<std::endl ;
    }

public :
    std::string name ;
} ;

class obj3
{
public :
    obj3( std::string n )
    {
        std::cout <<"create  "<<n<< std::endl ;
        name = n ;
    }

    void print ()
    {
        std::cout<<"print  " << name <<std::endl ;
    }

public :
    std::string name ;
} ;

typedef struct btnode
{
    std::string name ;
    btnode () :name(NULL)
    {}
    btnode ( std::string & n ) : name (n)
    {}
}BtNode_t ;

typedef boost::mpl::vector<obj1 , obj2 , obj3, BtNode_t> CacheableTypes ;


#endif //CacheablesTypes.hpp

// CachePool.hpp

#ifndef CACHE_POOL_HPP__
#define CACHE_POOL_HPP__

#include "SharedPtr.hpp"
#include <string>
#include <map>

template <typename T, typename Id = std::string>
class CachePool
{
public :
    typedef typename sharedptr<T>::type TPtr ;

    TPtr get( const Id &inId )
    {
        TPtr result = mCachePool[inId] ;

        if ( result )
            result = TPtr( new T(*result)) ;
        return result ;
    }

    const TPtr getConst ( const Id &inId )
    {
        return mCachePool[inId] ;
    }

    void add ( TPtr inPtr , const Id &inId )
    {
        TPtr copy( new T(*inPtr )) ;
        // new T( object )
        mCachePool[inId] = copy ;
    }

    void drop ()
    {
        mCachePool.clear() ;
    }

    void drop ( const Id &inId )
    {
        mCachePool[inId].reset() ;
    }


private :
    typedef std::map<Id, TPtr> CachePoolCont ;
    CachePoolCont mCachePool ;
} ;
#endif //CachePool.hpp

// Cache.hpp

#ifndef CACHE_HPP_
#define CACHE_HPP_

// mpl's transform
#include <boost/mpl/transform.hpp>

// fusion
#include <boost/fusion/include/map.hpp>
#include <boost/fusion/include/at_key.hpp>
#include <boost/fusion/include/pair.hpp>

// convert from MPL to fusion
#include <boost/fusion/adapted/mpl.hpp>
#include <boost/fusion/include/mpl.hpp>

#include <string>
#include <map>
#include <iostream>

#include "SharedPtr.hpp"
#include "CachePool.hpp"


template <typename TYPELIST>
class Cache
{
public :
    template <typename T>
    typename sharedptr<T>::type get ( const std::string &inId ) ;

    template <typename T>
    const typename sharedptr<T>::type getConst ( const std::string &inId) ;

    template <typename T>
    void add ( typename sharedptr<T>::type inPtr , const std::string &inId) ;

    template <typename T>
    void drop()
    {
        typename sharedptr< CachePool<T> >::type cachePool = getCachePool<T> () ;
        if ( cachePool )
            cachePool->drop () ;
    }

    template <typename T>
    void drop ( const std::string &inId )
    {
        typename sharedptr< CachePool<T> >::type cachePool = getCachePool<T> ()
        if ( cachePool )
            cachePool->drop(inId) ;
    }


    template <typename T>
    typename sharedptr<CachePool<T> >::type getCachePool ()
    {
        return boost::fusion::at_key<T>(mMap) ;
    }

    template <typename T>
    void addCachePool ()
    {
        std::cout << " now add pool " << std::endl ;
        boost::fusion::at_key<T>(mMap) = typename sharedptr<CachePool<T> >::type ( new CachePool<T> () ) ;
    }

private :
    struct MakePair
    {
        template <typename T>
        struct apply
        {
            typedef boost::fusion::pair<T,typename sharedptr<CachePool<T> >::type > type ;
        } ;
    } ;

    // generate pairs
    typedef typename boost::mpl::transform<TYPELIST,MakePair>::type PairedCacheableTypes ;
    typedef typename boost::fusion::result_of::as_map<PairedCacheableTypes>::type CacheMap_t ;

    CacheMap_t mMap ;


} ;


template <typename TYPELIST>
template <typename T>
typename sharedptr<T>::type Cache<TYPELIST>::get ( const std::string &inId)
{
    typename sharedptr<CachePool<T> >::type cachePool = getCachePool<T>() ;

    if ( !cachePool )
        return typename sharedptr<T>::type() ;

    return cachePool->get(inId) ;
}

template <typename TYPELIST>
template <typename T>
const typename sharedptr<T>::type Cache<TYPELIST>::getConst( const std::string &inId )
{
    // first we get the specified type CachePool
    typename sharedptr< CachePool<T> >::type cachePool = getCachePool<T> () ;

    if ( ! cachePool ) // no cache pool with type of T in Cache
        return sharedptr<T>::type () ;
    return cachePool->getConst( inId ) ;
}


template <typename TYPELIST>
template <typename T>
void Cache<TYPELIST>::add ( typename sharedptr<T>::type inPtr ,const std::string &inId )
{
    // first we get the cache pool object with the specified type of 'T'
    sharedptr< CachePool <T> >::type cachePool = getCachePool<T> () ;

    if ( !cachePool ) // if the pool is empty
      addCachePool<T> () ; // we add a cache pool object into cache map

    cachePool = getCachePool<T> () ;
    assert ( cachePool ) ;
    cachePool->add ( inPtr , inId ) ;

}

#endif // Cache.hpp

// Main.cpp

#include <cstdio>
#include <string>
#include <cstdlib>
#include <iostream>

#include "SharedPtr.hpp"
#include "CachePool.hpp"
#include "Cache.hpp"
#include "CacheableTypes.hpp"



int main ()
{
    // here we test Cache
    Cache<CacheableTypes> myCache ;

    sharedptr<obj1>::type pTest ( new obj1("inuyasha") ) ;

    myCache.add<obj1>( pTest, pTest->_name) ;

    std::cout <<"pTest " << std::endl ;
    pTest->print() ;
    pTest = sharedptr<obj1>::type () ;

    pTest = myCache.get<obj1>("inuyasha") ;

    pTest->print() ;


    // here i will test whether without add types into CacheableTYpes can insert it into the cache

    sharedptr<BtNode_t>::type pNode_test ( new BtNode_t(std::string ("nasume")) ) ;

    myCache.add<BtNode_t>(pNode_test , pNode_test->name) ;


    system("pause") ;
    return 0 ;
}

运行结果是这样的:


end

既然已经达到可以使用的程度了，在后面打算创建一个 file class 来替代 obj1 ，obj2 等类对象，
实现写文件、读文件的缓冲区。

就是设定一个缓冲区的阈值，每次计算一下要写入硬盘中的（写入文件中的）全部缓冲区的大小，达到阈值的时候，
将缓冲区的数据一起写入到硬盘中（文件中） ，这样可以减少频繁写入、读取硬盘的次数，
从某些角度上来说，可以保护银盘，（理论上是这么想到，实际上-----> 然而却并没有什么卵用）