8 #ifndef BOTAN_ALGORITHM_CACHE_TEMPLATE_H__     9 #define BOTAN_ALGORITHM_CACHE_TEMPLATE_H__    11 #include <botan/internal/mutex.h>    12 #include <botan/internal/stl_util.h>    37       const T* 
get(
const std::string& algo_spec,
    38                    const std::string& pref_provider);
    47                const std::string& requested_name,
    48                const std::string& provider_name);
    56                                   const std::string& provider);
    63       std::vector<std::string> 
providers_of(
const std::string& algo_name);
    77       typedef typename std::map<std::string, std::map<std::string, T*> >::iterator
    80       typedef typename std::map<std::string, T*>::iterator provider_iterator;
    82       algorithms_iterator find_algorithm(
const std::string& algo_spec);
    85       std::map<std::string, std::string> aliases;
    86       std::map<std::string, std::string> pref_providers;
    87       std::map<std::string, std::map<std::string, T*> > algorithms;
    95 typename Algorithm_Cache<T>::algorithms_iterator
    98    algorithms_iterator algo = algorithms.find(algo_spec);
   101    if(algo == algorithms.end())
   103       std::map<std::string, std::string>::const_iterator alias =
   104          aliases.find(algo_spec);
   106       if(alias != aliases.end())
   107          algo = algorithms.find(alias->second);
   118                                  const std::string& requested_provider)
   122    algorithms_iterator algo = find_algorithm(algo_spec);
   123    if(algo == algorithms.end()) 
   127    if(requested_provider != 
"")
   129       provider_iterator prov = algo->second.find(requested_provider);
   130       if(prov != algo->second.end())
   135    const T* prototype = 0;
   136    std::string prototype_provider;
   137    size_t prototype_prov_weight = 0;
   139    const std::string pref_provider = 
search_map(pref_providers, algo_spec);
   141    for(provider_iterator i = algo->second.begin(); i != algo->second.end(); ++i)
   143       const std::string prov_name = i->first;
   147       if(prov_name == pref_provider)
   150       if(prototype == 0 || prov_weight > prototype_prov_weight)
   152          prototype = i->second;
   153          prototype_provider = i->first;
   154          prototype_prov_weight = prov_weight;
   166                              const std::string& requested_name,
   167                              const std::string& provider)
   174    if(algo->name() != requested_name &&
   175       aliases.find(requested_name) == aliases.end())
   177       aliases[requested_name] = algo->name();
   180    if(!algorithms[algo->name()][provider])
   181       algorithms[algo->name()][provider] = algo;
   189 template<
typename T> std::vector<std::string>
   194    std::vector<std::string> providers;
   196    algorithms_iterator algo = find_algorithm(algo_name);
   198    if(algo != algorithms.end())
   200       provider_iterator provider = algo->second.begin();
   202       while(provider != algo->second.end())
   204          providers.push_back(provider->first);
   217                                                 const std::string& provider)
   221    pref_providers[algo_spec] = provider;
   230    algorithms_iterator algo = algorithms.begin();
   232    while(algo != algorithms.end())
   234       provider_iterator provider = algo->second.begin();
   236       while(provider != algo->second.end())
   238          delete provider->second;
 const T * get(const std::string &algo_spec, const std::string &pref_provider)
V search_map(const std::map< K, V > &mapping, const K &key, const V &null_result=V())
std::vector< std::string > providers_of(const std::string &algo_name)
size_t static_provider_weight(const std::string &prov_name)
void add(T *algo, const std::string &requested_name, const std::string &provider_name)
void set_preferred_provider(const std::string &algo_spec, const std::string &provider)
Algorithm_Cache(Mutex *m)