Botan::Algorithm_Cache< T > Class Template Reference

#include <algo_cache.h>

Public Member Functions
void	add (T *algo, const std::string &requested_name, const std::string &provider_name)
	Algorithm_Cache (Mutex *m)
void	clear_cache ()
const T *	get (const std::string &algo_spec, const std::string &pref_provider)
std::vector< std::string >	providers_of (const std::string &algo_name)
void	set_preferred_provider (const std::string &algo_spec, const std::string &provider)
	~Algorithm_Cache ()

Detailed Description

template<typename T>
class Botan::Algorithm_Cache< T >

Algorithm_Cache (used by Algorithm_Factory)

Definition at line 29 of file algo_cache.h.

Constructor & Destructor Documentation

Algorithm_Cache()

template<typename T>

Botan::Algorithm_Cache< T >::Algorithm_Cache ( Mutex * m )

inline

Constructor

Parameters

m	a mutex to serialize internal access

Definition at line 74 of file algo_cache.h.

: mutex(m) {}

Referenced by Botan::Algorithm_Factory::Algorithm_Factory().

~Algorithm_Cache()

template<typename T>

Botan::Algorithm_Cache< T >::~Algorithm_Cache ( )

inline

Definition at line 75 of file algo_cache.h.

{ clear_cache(); delete mutex; }

References clear_cache().

Member Function Documentation

add()

template<typename T>

void Botan::Algorithm_Cache< T >::add	(	T *	algo,
		const std::string &	requested_name,
		const std::string &	provider_name )

Add a new algorithm implementation to the cache

Parameters

algo	the algorithm prototype object
requested_name	how this name will be requested
provider_name	is the name of the provider of this prototype

Definition at line 165 of file algo_cache.h.

   {
   if(!algo)
      return;
 
   Mutex_Holder lock(mutex);
 
   if(algo->name() != requested_name &&
      aliases.find(requested_name) == aliases.end())
      {
      aliases[requested_name] = algo->name();
      }
 
   if(!algorithms[algo->name()][provider])
      algorithms[algo->name()][provider] = algo;
   else
      delete algo;
   }

clear_cache()

template<typename T>

void Botan::Algorithm_Cache< T >::clear_cache

(

)

Clear the cache

Definition at line 228 of file algo_cache.h.

   {
   algorithms_iterator algo = algorithms.begin();
 
   while(algo != algorithms.end())
      {
      provider_iterator provider = algo->second.begin();
 
      while(provider != algo->second.end())
         {
         delete provider->second;
         ++provider;
         }
 
      ++algo;
      }
 
   algorithms.clear();
   }

Referenced by ~Algorithm_Cache().

get()

template<typename T>

const T * Botan::Algorithm_Cache< T >::get	(	const std::string &	algo_spec,
		const std::string &	pref_provider )

Parameters

algo_spec	names the requested algorithm
pref_provider	suggests a preferred provider

Returns

prototype object, or NULL

Definition at line 117 of file algo_cache.h.

   {
   Mutex_Holder lock(mutex);
 
   algorithms_iterator algo = find_algorithm(algo_spec);
   if(algo == algorithms.end()) // algo not found at all (no providers)
      return 0;
 
   // If a provider is requested specifically, return it or fail entirely
   if(requested_provider != "")
      {
      provider_iterator prov = algo->second.find(requested_provider);
      if(prov != algo->second.end())
         return prov->second;
      return 0;
      }
 
   const T* prototype = 0;
   std::string prototype_provider;
   size_t prototype_prov_weight = 0;
 
   const std::string pref_provider = search_map(pref_providers, algo_spec);
 
   for(provider_iterator i = algo->second.begin(); i != algo->second.end(); ++i)
      {
      const std::string prov_name = i->first;
      const size_t prov_weight = static_provider_weight(prov_name);
 
      // preferred prov exists, return immediately
      if(prov_name == pref_provider)
         return i->second;
 
      if(prototype == 0 || prov_weight > prototype_prov_weight)
         {
         prototype = i->second;
         prototype_provider = i->first;
         prototype_prov_weight = prov_weight;
         }
      }
 
   return prototype;
   }

References Botan::search_map(), and Botan::static_provider_weight().

providers_of()

template<typename T>

std::vector< std::string > Botan::Algorithm_Cache< T >::providers_of

(

const std::string &

algo_name

)

Return the list of providers of this algorithm

Parameters

algo_name

names the algorithm

Returns

list of providers of this algorithm

Definition at line 190 of file algo_cache.h.

   {
   Mutex_Holder lock(mutex);
 
   std::vector<std::string> providers;
 
   algorithms_iterator algo = find_algorithm(algo_name);
 
   if(algo != algorithms.end())
      {
      provider_iterator provider = algo->second.begin();
 
      while(provider != algo->second.end())
         {
         providers.push_back(provider->first);
         ++provider;
         }
      }
 
   return providers;
   }

set_preferred_provider()

template<typename T>

void Botan::Algorithm_Cache< T >::set_preferred_provider	(	const std::string &	algo_spec,
		const std::string &	provider )

Set the preferred provider

Parameters

algo_spec	names the algorithm
provider	names the preferred provider

Definition at line 216 of file algo_cache.h.

   {
   Mutex_Holder lock(mutex);
 
   pref_providers[algo_spec] = provider;
   }

---

The documentation for this class was generated from the following file:

• src/algo_factory/algo_cache.h