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