00001 #ifndef CRYPTOPP_OBJFACT_H
00002 #define CRYPTOPP_OBJFACT_H
00003
00004 #include "cryptlib.h"
00005 #include <map>
00006 #include <vector>
00007
00008 NAMESPACE_BEGIN(CryptoPP)
00009
00010
00011 template <class AbstractClass>
00012 class ObjectFactory
00013 {
00014 public:
00015 virtual ~ObjectFactory () {}
00016 virtual AbstractClass * CreateObject() const =0;
00017 };
00018
00019
00020 template <class AbstractClass, class ConcreteClass>
00021 class DefaultObjectFactory : public ObjectFactory<AbstractClass>
00022 {
00023 public:
00024 AbstractClass * CreateObject() const
00025 {
00026 return new ConcreteClass;
00027 }
00028
00029 };
00030
00031
00032 template <class AbstractClass, int instance=0>
00033 class ObjectFactoryRegistry
00034 {
00035 public:
00036 class FactoryNotFound : public Exception
00037 {
00038 public:
00039 FactoryNotFound(const char *name) : Exception(OTHER_ERROR, std::string("ObjectFactoryRegistry: could not find factory for algorithm ") + name) {}
00040 };
00041
00042 ~ObjectFactoryRegistry()
00043 {
00044 for (CPP_TYPENAME Map::iterator i = m_map.begin(); i != m_map.end(); ++i)
00045 {
00046 delete (ObjectFactory<AbstractClass> *)i->second;
00047 i->second = NULL;
00048 }
00049 }
00050
00051 void RegisterFactory(const std::string &name, ObjectFactory<AbstractClass> *factory)
00052 {
00053 m_map[name] = factory;
00054 }
00055
00056 const ObjectFactory<AbstractClass> * GetFactory(const char *name) const
00057 {
00058 CPP_TYPENAME Map::const_iterator i = m_map.find(name);
00059 return i == m_map.end() ? NULL : (ObjectFactory<AbstractClass> *)i->second;
00060 }
00061
00062 AbstractClass *CreateObject(const char *name) const
00063 {
00064 const ObjectFactory<AbstractClass> *factory = GetFactory(name);
00065 if (!factory)
00066 throw FactoryNotFound(name);
00067 return factory->CreateObject();
00068 }
00069
00070
00071
00072 std::vector<std::string> GetFactoryNames() const
00073 {
00074 std::vector<std::string> names;
00075 CPP_TYPENAME Map::const_iterator iter;
00076 for (iter = m_map.begin(); iter != m_map.end(); ++iter)
00077 names.push_back(iter->first);
00078 return names;
00079 }
00080
00081 CRYPTOPP_NOINLINE static ObjectFactoryRegistry<AbstractClass, instance> & Registry(CRYPTOPP_NOINLINE_DOTDOTDOT);
00082
00083 private:
00084
00085 typedef std::map<std::string, void *> Map;
00086 Map m_map;
00087 };
00088
00089 template <class AbstractClass, int instance>
00090 ObjectFactoryRegistry<AbstractClass, instance> & ObjectFactoryRegistry<AbstractClass, instance>::Registry(CRYPTOPP_NOINLINE_DOTDOTDOT)
00091 {
00092 static ObjectFactoryRegistry<AbstractClass, instance> s_registry;
00093 return s_registry;
00094 }
00095
00096 template <class AbstractClass, class ConcreteClass, int instance = 0>
00097 struct RegisterDefaultFactoryFor {
00098 RegisterDefaultFactoryFor(const char *name=NULL)
00099 {
00100
00101 std::string n = name ? std::string(name) : std::string(ConcreteClass::StaticAlgorithmName());
00102 ObjectFactoryRegistry<AbstractClass, instance>::Registry().
00103 RegisterFactory(n, new DefaultObjectFactory<AbstractClass, ConcreteClass>);
00104 }};
00105
00106 template <class SchemeClass>
00107 void RegisterAsymmetricCipherDefaultFactories(const char *name=NULL, SchemeClass *dummy=NULL)
00108 {
00109 RegisterDefaultFactoryFor<PK_Encryptor, CPP_TYPENAME SchemeClass::Encryptor>((const char *)name);
00110 RegisterDefaultFactoryFor<PK_Decryptor, CPP_TYPENAME SchemeClass::Decryptor>((const char *)name);
00111 }
00112
00113 template <class SchemeClass>
00114 void RegisterSignatureSchemeDefaultFactories(const char *name=NULL, SchemeClass *dummy=NULL)
00115 {
00116 RegisterDefaultFactoryFor<PK_Signer, CPP_TYPENAME SchemeClass::Signer>((const char *)name);
00117 RegisterDefaultFactoryFor<PK_Verifier, CPP_TYPENAME SchemeClass::Verifier>((const char *)name);
00118 }
00119
00120 template <class SchemeClass>
00121 void RegisterSymmetricCipherDefaultFactories(const char *name=NULL, SchemeClass *dummy=NULL)
00122 {
00123 RegisterDefaultFactoryFor<SymmetricCipher, CPP_TYPENAME SchemeClass::Encryption, ENCRYPTION>((const char *)name);
00124 RegisterDefaultFactoryFor<SymmetricCipher, CPP_TYPENAME SchemeClass::Decryption, DECRYPTION>((const char *)name);
00125 }
00126
00127 template <class SchemeClass>
00128 void RegisterAuthenticatedSymmetricCipherDefaultFactories(const char *name=NULL, SchemeClass *dummy=NULL)
00129 {
00130 RegisterDefaultFactoryFor<AuthenticatedSymmetricCipher, CPP_TYPENAME SchemeClass::Encryption, ENCRYPTION>((const char *)name);
00131 RegisterDefaultFactoryFor<AuthenticatedSymmetricCipher, CPP_TYPENAME SchemeClass::Decryption, DECRYPTION>((const char *)name);
00132 }
00133
00134 NAMESPACE_END
00135
00136 #endif