Changeset 5611


Ignore:
Timestamp:
10/05/08 21:55:09 (6 years ago)
Author:
jdsiiro
Message:

More work on the COLIN caching system: adding registry capabilities to
the ResponseCacheFactory?.

Location:
colin/branches/colin-appresponse-dev
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • colin/branches/colin-appresponse-dev/colin/ResponseCache.h

    r5585 r5611  
    2424#include <utilib/Any.h> 
    2525#include <utilib/SharedPtr.h> 
     26 
     27class TiXmlElement; 
    2628 
    2729namespace colin 
     
    170172   get_annotations( const OptApplication_Base* app, Key key ) const = 0; 
    171173 
     174 
     175   /// Configure this cache 
     176   void configure(TiXmlElement *elmt); 
    172177    
    173178protected: 
     179 
     180   typedef void(*fcn_cb_tixml_t)(ResponseCache*, TiXmlElement*); 
    174181 
    175182   /// 
     
    186193                const std::map<response_info_t, const utilib::Any> &new_data ) 
    187194   { cache_data.insert(seed, new_data); } 
    188     
     195 
     196   /// Register a new handler for XML configuration 
     197   void register_configure(std::string element, fcn_cb_tixml_t fcn); 
    189198 
    190199private: 
     200   /// 
    191201   utilib::SharedPtr<KeyGenerator> keygen; 
     202   /// 
     203   std::map<std::string, fcn_cb_tixml_t> cfg_callbacks; 
    192204}; 
    193205 
  • colin/branches/colin-appresponse-dev/colin/ResponseCacheFactory.h

    r5539 r5611  
    5050 
    5151   /// 
    52    bool register_cache(std::string name, cache_create_fcn_t fcn); 
     52   bool declare_cache_type(std::string name, cache_create_fcn_t fcn); 
    5353 
    5454   /// 
    55    bool register_indexer(std::string name, indexer_create_fcn_t fcn); 
     55   bool declare_indexer_type(std::string name, indexer_create_fcn_t fcn); 
    5656 
    5757   /// 
    5858   ResponseCache* create(std::string name = "", std::string indexer = ""); 
     59 
     60   /// 
     61   ResponseCache* register_cache(ResponseCache* cache, std::string name); 
     62 
     63   /// 
     64   void unregister_cache(std::string name); 
    5965 
    6066private: 
  • colin/branches/colin-appresponse-dev/src/KeyGenerator_EpsilonMatch.cpp

    r5567 r5611  
    6565bool RegisterEpsilonMatch() 
    6666{ 
    67    CacheFactory().register_indexer("Epsilon", create_epsilon_indexer); 
     67   CacheFactory().declare_indexer_type("Epsilon", create_epsilon_indexer); 
    6868   return true; 
    6969} 
  • colin/branches/colin-appresponse-dev/src/ResponseCache.cpp

    r5585 r5611  
    1616#include <colin/ResponseCache.h> 
    1717#include <colin/ResponseCacheFactory.h> 
     18#include <colin/TinyXML_helper.h> 
    1819 
    1920using std::cerr; 
     
    7374 
    7475 
     76void ResponseCache::configure(TiXmlElement* elmt) 
     77{ 
     78   if ( elmt == NULL ) 
     79      return; 
     80    
     81   TiXmlElement *node = elmt->FirstChildElement();  
     82   map<string, fcn_cb_tixml_t>::iterator it; 
     83   for ( ; node != NULL; node = node->NextSiblingElement() ) 
     84   { 
     85      it = cfg_callbacks.find(node->ValueStr()); 
     86      if ( it == cfg_callbacks.end() ) 
     87         EXCEPTION_MNGR(std::runtime_error, "ResponseCache::configure(): No " 
     88                        "callback registered for " << get_element_info(node)); 
     89      it->second(this, node); 
     90   } 
     91} 
     92 
     93 
     94void ResponseCache::register_configure(std::string element, fcn_cb_tixml_t fcn) 
     95{ 
     96   if ( ! cfg_callbacks.insert(make_pair(element, fcn)).second ) 
     97      EXCEPTION_MNGR(std::runtime_error, "ResponseCache::register_configure(): " 
     98                     "duplicate callback registered for element, '" << element 
     99                     << "'"); 
     100} 
    75101 
    76102} // namespace colin 
  • colin/branches/colin-appresponse-dev/src/ResponseCacheFactory.cpp

    r5539 r5611  
    1616#include<colin/ResponseCacheFactory.h> 
    1717#include<colin/ResponseCache.h> 
     18#include<colin/XMLProcessor.h> 
     19#include<colin/TinyXML_helper.h> 
    1820 
    1921using std::cerr; 
     
    2527 
    2628namespace colin { 
     29 
     30class CacheElementFunctor : public XML_Processor::ElementFunctor 
     31{ 
     32   virtual void process(TiXmlElement* root, int version) 
     33   { 
     34      static_cast<void>(version); 
     35      string type; 
     36      get_string_attribute(root, "type", type, ""); 
     37      string indexer; 
     38      get_string_attribute(root, "indexer", indexer, "Exact"); 
     39      string name; 
     40      get_string_attribute(root, "name", name, ""); 
     41 
     42      CacheFactory().register_cache(CacheFactory().create(type, indexer), name) 
     43         ->configure(root); 
     44   } 
     45 
     46   virtual void describe(std::ostream &os, size_t indent = 0) const 
     47   { 
     48      for( ; indent > 0; --indent ) 
     49         os << XML_Processor::indent_string; 
     50      os << "Please implement CacheElementFunctor::describe" << endl; 
     51   } 
     52}; 
    2753 
    2854 
     
    119145        default_indexer_name("Exact") 
    120146   { 
    121       cache_registry.insert( cache_registry.end(),  
     147      cache_factory.insert( cache_factory.end(),  
    122148                             make_pair("None", create_no_cache) ); 
    123       indexer_registry.insert( indexer_registry.end(),  
     149      indexer_factory.insert( indexer_factory.end(),  
    124150                               make_pair("Exact", create_exact_indexer) ); 
    125       indexer_registry.insert( indexer_registry.end(),  
     151      indexer_factory.insert( indexer_factory.end(),  
    126152                               make_pair("Unique", create_unique_indexer) ); 
    127153   } 
     
    129155 
    130156   /// 
    131    map<string, cache_create_fcn_t>  cache_registry; 
    132    /// 
    133    map<string, indexer_create_fcn_t>  indexer_registry; 
     157   map<string, cache_create_fcn_t>  cache_factory; 
     158   /// 
     159   map<string, indexer_create_fcn_t>  indexer_factory; 
    134160   /// 
    135161   string  default_cache_name; 
    136162   /// 
    137163   string  default_indexer_name; 
     164 
     165   /// 
     166   map<string, ResponseCache*> cache_registry; 
    138167}; 
    139168 
     
    141170ResponseCacheFactory::ResponseCacheFactory() 
    142171   : data(new Data) 
    143 {} 
     172{ 
     173   XMLProcessor().register_element("Cache", 1, new CacheElementFunctor); 
     174} 
    144175 
    145176 
    146177ResponseCacheFactory::~ResponseCacheFactory() 
    147178{ 
     179   // delete all remaining registered caches... 
     180   map<string, ResponseCache*>::iterator it = data->cache_registry.begin(); 
     181   map<string, ResponseCache*>::iterator itEnd = data->cache_registry.end(); 
     182   for( ; it != itEnd; ++it ) 
     183      delete it->second; 
     184 
    148185   delete data; 
    149186} 
     
    168205 
    169206bool  
    170 ResponseCacheFactory::register_cache(std::string name, cache_create_fcn_t fcn) 
    171 { 
    172    if ( ! data->cache_registry.insert(make_pair(name, fcn)).second ) 
     207ResponseCacheFactory:: 
     208declare_cache_type(std::string name, cache_create_fcn_t fcn) 
     209{ 
     210   if ( ! data->cache_factory.insert(make_pair(name, fcn)).second ) 
    173211   { 
    174212      EXCEPTION_MNGR(std::runtime_error, "ResponseCacheFactory::" 
     
    183221 
    184222bool  
    185 ResponseCacheFactory::register_indexer( std::string name,  
    186                                         indexer_create_fcn_t fcn ) 
    187 { 
    188    if ( ! data->indexer_registry.insert(make_pair(name, fcn)).second ) 
     223ResponseCacheFactory:: 
     224declare_indexer_type(std::string name, indexer_create_fcn_t fcn) 
     225{ 
     226   if ( ! data->indexer_factory.insert(make_pair(name, fcn)).second ) 
    189227   { 
    190228      EXCEPTION_MNGR(std::runtime_error, "ResponseCacheFactory::" 
     
    204242 
    205243   map<string, cache_create_fcn_t>::iterator c_it  
    206       = data->cache_registry.find(name); 
    207    if ( c_it == data->cache_registry.end() ) 
     244      = data->cache_factory.find(name); 
     245   if ( c_it == data->cache_factory.end() ) 
    208246      EXCEPTION_MNGR(std::runtime_error, "ResponseCacheFactory::create(): " 
    209247                     "unknown cache name, '" << name << "'"); 
     
    217255 
    218256   map<string, indexer_create_fcn_t>::iterator i_it 
    219       = data->indexer_registry.find(indexer); 
    220    if ( i_it == data->indexer_registry.end() ) 
     257      = data->indexer_factory.find(indexer); 
     258   if ( i_it == data->indexer_factory.end() ) 
    221259      EXCEPTION_MNGR(std::runtime_error, "ResponseCacheFactory::create(): " 
    222260                     "unknown indexer name, '" << indexer << "'"); 
     
    225263} 
    226264 
     265 
     266ResponseCache* 
     267ResponseCacheFactory::register_cache(ResponseCache* cache, std::string name) 
     268{ 
     269   if ( cache == NULL ) 
     270      EXCEPTION_MNGR(std::runtime_error, "ResponseCacheFactory::" 
     271                     "register_cache(): refusing to register NULL cache."); 
     272   if ( name.empty() ) 
     273      EXCEPTION_MNGR(std::runtime_error, "ResponseCacheFactory::" 
     274                     "register_cache(): refusing to register unnamed cache."); 
     275   if ( ! data->cache_registry.insert(make_pair(name,cache)).second ) 
     276      EXCEPTION_MNGR(std::runtime_error, "ResponseCacheFactory::" 
     277                     "register_cache(): duplicate cache name, '"  
     278                     << name << "'"); 
     279   return cache; 
     280} 
     281 
     282void 
     283ResponseCacheFactory::unregister_cache(std::string name) 
     284{ 
     285   map<string, ResponseCache*>::iterator it = data->cache_registry.find(name); 
     286   if ( it == data->cache_registry.end() )  
     287      EXCEPTION_MNGR(std::runtime_error, "ResponseCacheFactory::" 
     288                     "unregister_cache(): unknown cache, '" << name << "'"); 
     289   delete it->second; 
     290   data->cache_registry.erase(it); 
     291} 
     292 
    227293} // namespace colin 
  • colin/branches/colin-appresponse-dev/src/ResponseCache_Local.cpp

    r5585 r5611  
    4444bool RegisterLocalCache() 
    4545{ 
    46    CacheFactory().register_cache("Local", create_local_cache); 
     46   CacheFactory().declare_cache_type("Local", create_local_cache); 
    4747   return true; 
    4848} 
  • colin/branches/colin-appresponse-dev/src/ResponseCache_MasterSlave.cpp

    r5585 r5611  
    5656bool RegisterMasterSlaveCache() 
    5757{ 
    58    CacheFactory().register_cache("MasterSlave", create_masterSlave_cache); 
     58   CacheFactory().declare_cache_type("MasterSlave", create_masterSlave_cache); 
    5959   return true; 
    6060} 
Note: See TracChangeset for help on using the changeset viewer.