Figure 3: The factory class

template <class KEY, class BASE>
class factory {
   public:
      typedef creator_base<BASE> creator;
      typedef creator_base<BASE>::parameters parameters;
      typedef std::set<KEY> keys;
      typedef std::map<std::string, keys> libraries;
      typedef std::map<KEY, creator*> creators;
  public:
      static BASE* create(const KEY& key) {
         return get_instance().internal_create(key);
      }
#ifdef REGIME_FACTORY_PARAMS
      static BASE* create(const KEY& key, const parameters& p) {
         return get_instance().internal_create(key, p);
      }
#endif

      static void clean() {
         get_instance().internal_clean();
      }
      static void clean(const KEY& key) {
         get_instance().internal_clean(key);
      }

      static const std::string& get_current_library() {
         return get_instance().internal_get_current_library();
      }
      static void load_library(const std::string& library) {
         get_instance().internal_load_library(library, false);
      }
      static void load_key(const std::string& key) {
         get_instance().internal_load_key(key);
      }
      static void unload_library(const std::string& library) {
         get_instance().internal_unload_library(library);
      }
      static void unload_key(const std::string& key) {
         get_instance().internal_unload_key(key);
      }
      static load_strategy<KEY>* 
      set_load_strategy(load_strategy<KEY>* strategy) {
         return 
            get_instance().internal_set_load_strategy(strategy);
      }
      static const libraries& query_libraries() {
         return get_instance().internal_query_libraries();
      }
      static const keys& 
      query_library(const std::string& library) {
         return get_instance().internal_query_library(library);
      }
      static const keys& query_keys() {
         return get_instance().internal_query_keys();
      }
      static void register_creator(const KEY& key, creator* c) {
         get_instance().internal_register_creator(key, c);
      }
      static void 
      unregister_creator(const KEY& key, creator* c) {
         get_instance().internal_unregister_creator(key, c);
      }
      //==================================================
      // Instance handling
      //==================================================
   private:
      static KAPI factory<KEY,BASE>& get_instance();
# ifdef REGIME_FACTORY_PARAMS
      virtual BASE* 
      internal_create(const KEY&, const parameters&) = 0;
# endif
      virtual BASE* internal_create(const KEY&) = 0;
      virtual void internal_clean() = 0;
      virtual void internal_clean(const KEY&) = 0;
      virtual void internal_load_key(const KEY&) = 0;
      virtual const std::string& 
      internal_get_current_library() const = 0;
      virtual void 
      internal_load_library(const std::string& library, 
         bool is_auto) = 0;
      virtual void 
      internal_unload_library(const std::string& library) = 0;
      virtual void internal_unload_key(const KEY&) = 0;
      virtual load_strategy<KEY>* 
      internal_set_load_strategy(load_strategy<KEY>*) = 0;
      virtual const libraries& 
      internal_query_libraries() const = 0;
      virtual const keys& 
      internal_query_library
         (const std::string& library) const = 0;
      virtual const keys& internal_query_keys() const = 0;
      virtual void 
      internal_register_creator(const KEY&, creator*) = 0;
      virtual void 
      internal_unregister_creator(const KEY&, creator*) = 0;
  };