include/cryptopp/factory.h

0001 // factory.h - originally written and placed in the public domain by Wei Dai

0002
0003 /// \file factory.h

0004 /// \brief Classes and functions for registering and locating library objects

0005
0006 #ifndef CRYPTOPP_OBJFACT_H
0007 #define CRYPTOPP_OBJFACT_H
0008
0009 #include "cryptlib.h"
0010 #include "misc.h"
0011 #include "stdcpp.h"
0012
0013 NAMESPACE_BEGIN(CryptoPP)
0014
0015 /// \brief Object factory interface for registering objects

0016 /// \tparam AbstractClass Base class interface of the object

0017 template <class AbstractClass>
0018 class ObjectFactory
0019 {
0020 public:
0021     virtual ~ObjectFactory () {}
0022     virtual AbstractClass * CreateObject() const =0;
0023 };
0024
0025 /// \brief Object factory for registering objects

0026 /// \tparam AbstractClass Base class interface of the object

0027 /// \tparam ConcreteClass Class object

0028 template <class AbstractClass, class ConcreteClass>
0029 class DefaultObjectFactory : public ObjectFactory<AbstractClass>
0030 {
0031 public:
0032     AbstractClass * CreateObject() const
0033     {
0034         return new ConcreteClass;
0035     }
0036 };
0037
0038 /// \brief Object factory registry

0039 /// \tparam AbstractClass Base class interface of the object

0040 /// \tparam instance unique identifier

0041 template <class AbstractClass, int instance=0>
0042 class ObjectFactoryRegistry
0043 {
0044 public:
0045     class FactoryNotFound : public Exception
0046     {
0047     public:
0048         FactoryNotFound(const char *name) : Exception(OTHER_ERROR, std::string("ObjectFactoryRegistry: could not find factory for algorithm ") + name)  {}
0049     };
0050
0051     ~ObjectFactoryRegistry()
0052     {
0053         for (typename Map::iterator i = m_map.begin(); i != m_map.end(); ++i)
0054         {
0055             delete (ObjectFactory<AbstractClass> *)i->second;
0056             i->second = NULLPTR;
0057         }
0058     }
0059
0060     void RegisterFactory(const std::string &name, ObjectFactory<AbstractClass> *factory)
0061     {
0062         m_map[name] = factory;
0063     }
0064
0065     const ObjectFactory<AbstractClass> * GetFactory(const char *name) const
0066     {
0067         typename Map::const_iterator i = m_map.find(name);
0068         return i == m_map.end() ? NULLPTR : (ObjectFactory<AbstractClass> *)i->second;
0069     }
0070
0071     AbstractClass *CreateObject(const char *name) const
0072     {
0073         const ObjectFactory<AbstractClass> *factory = GetFactory(name);
0074         if (!factory)
0075             throw FactoryNotFound(name);
0076         return factory->CreateObject();
0077     }
0078
0079     // Return a vector containing the factory names. This is easier than returning an iterator.

0080     // from Andrew Pitonyak

0081     std::vector<std::string> GetFactoryNames() const
0082     {
0083         std::vector<std::string> names;
0084         typename Map::const_iterator iter;
0085         for (iter = m_map.begin(); iter != m_map.end(); ++iter)
0086             names.push_back(iter->first);
0087         return names;
0088     }
0089
0090     CRYPTOPP_NOINLINE static ObjectFactoryRegistry<AbstractClass, instance> & Registry(CRYPTOPP_NOINLINE_DOTDOTDOT);
0091
0092 private:
0093     // use void * instead of ObjectFactory<AbstractClass> * to save code size

0094     typedef std::map<std::string, void *> Map;
0095     Map m_map;
0096 };
0097
0098 template <class AbstractClass, int instance>
0099 ObjectFactoryRegistry<AbstractClass, instance> & ObjectFactoryRegistry<AbstractClass, instance>::Registry(CRYPTOPP_NOINLINE_DOTDOTDOT)
0100 {
0101     static ObjectFactoryRegistry<AbstractClass, instance> s_registry;
0102     return s_registry;
0103 }
0104
0105 /// \brief Object factory registry helper

0106 /// \tparam AbstractClass Base class interface of the object

0107 /// \tparam ConcreteClass Class object

0108 /// \tparam instance unique identifier

0109 template <class AbstractClass, class ConcreteClass, int instance = 0>
0110 struct RegisterDefaultFactoryFor
0111 {
0112     RegisterDefaultFactoryFor(const char *name=NULLPTR)
0113     {
0114         // BCB2006 workaround

0115         std::string n = name ? std::string(name) : std::string(ConcreteClass::StaticAlgorithmName());
0116         ObjectFactoryRegistry<AbstractClass, instance>::Registry().
0117         RegisterFactory(n, new DefaultObjectFactory<AbstractClass, ConcreteClass>);
0118     }
0119 };
0120
0121 /// \fn RegisterAsymmetricCipherDefaultFactories

0122 /// \brief Register asymmetric ciphers

0123 /// \tparam SchemeClass interface of the object under a scheme

0124 /// \details Schemes include asymmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>),

0125 ///   signature schemes (registers <tt>SchemeClass::Signer</tt> and <tt>SchemeClass::Verifier</tt>),

0126 ///   symmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>),

0127 ///   authenticated symmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>), etc.

0128 template <class SchemeClass>
0129 void RegisterAsymmetricCipherDefaultFactories(const char *name=NULLPTR)
0130 {
0131     RegisterDefaultFactoryFor<PK_Encryptor, typename SchemeClass::Encryptor>((const char *)name);
0132     RegisterDefaultFactoryFor<PK_Decryptor, typename SchemeClass::Decryptor>((const char *)name);
0133 }
0134
0135 /// \fn RegisterSignatureSchemeDefaultFactories

0136 /// \brief Register signature schemes

0137 /// \tparam SchemeClass interface of the object under a scheme

0138 /// \details Schemes include asymmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>),

0139 ///   signature schemes (registers <tt>SchemeClass::Signer</tt> and <tt>SchemeClass::Verifier</tt>),

0140 ///   symmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>),

0141 ///   authenticated symmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>), etc.

0142 template <class SchemeClass>
0143 void RegisterSignatureSchemeDefaultFactories(const char *name=NULLPTR)
0144 {
0145     RegisterDefaultFactoryFor<PK_Signer, typename SchemeClass::Signer>((const char *)name);
0146     RegisterDefaultFactoryFor<PK_Verifier, typename SchemeClass::Verifier>((const char *)name);
0147 }
0148
0149 /// \fn RegisterSymmetricCipherDefaultFactories

0150 /// \brief Register symmetric ciphers

0151 /// \tparam SchemeClass interface of the object under a scheme

0152 /// \details Schemes include asymmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>),

0153 ///   signature schemes (registers <tt>SchemeClass::Signer</tt> and <tt>SchemeClass::Verifier</tt>),

0154 ///   symmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>),

0155 ///   authenticated symmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>), etc.

0156 template <class SchemeClass>
0157 void RegisterSymmetricCipherDefaultFactories(const char *name=NULLPTR)
0158 {
0159     RegisterDefaultFactoryFor<SymmetricCipher, typename SchemeClass::Encryption, ENCRYPTION>((const char *)name);
0160     RegisterDefaultFactoryFor<SymmetricCipher, typename SchemeClass::Decryption, DECRYPTION>((const char *)name);
0161 }
0162
0163 /// \fn RegisterAuthenticatedSymmetricCipherDefaultFactories

0164 /// \brief Register authenticated symmetric ciphers

0165 /// \tparam SchemeClass interface of the object under a scheme

0166 /// \details Schemes include asymmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>),

0167 ///   signature schemes (registers <tt>SchemeClass::Signer</tt> and <tt>SchemeClass::Verifier</tt>),

0168 ///   symmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>),

0169 ///   authenticated symmetric ciphers (registers <tt>SchemeClass::Encryptor</tt> and <tt>SchemeClass::Decryptor</tt>), etc.

0170 template <class SchemeClass>
0171 void RegisterAuthenticatedSymmetricCipherDefaultFactories(const char *name=NULLPTR)
0172 {
0173     RegisterDefaultFactoryFor<AuthenticatedSymmetricCipher, typename SchemeClass::Encryption, ENCRYPTION>((const char *)name);
0174     RegisterDefaultFactoryFor<AuthenticatedSymmetricCipher, typename SchemeClass::Decryption, DECRYPTION>((const char *)name);
0175 }
0176
0177 NAMESPACE_END
0178
0179 #endif