[Boost-commit] svn:boost r39124 - in sandbox: boost/extension libs/extension/test

From: sixtrillion_at_[hidden]
Date: 2007-09-04 23:56:50

Author: sixtrillion
Date: 2007-09-04 23:56:48 EDT (Tue, 04 Sep 2007)
New Revision: 39124
URL: http://svn.boost.org/trac/boost/changeset/39124

Log:
This includes the initial changes to the Boost.Extension interfaces.

They all require Boost.Preprocessor now, though a non-Preprocessor version may be created in the future.

Most of the unit tests have been disabled temporarily, as I work to change their usage of the API.

The shared_library API will still be changed.

Added:
   sandbox/boost/extension/common.hpp   (contents, props changed)
Removed:
   sandbox/boost/extension/counted_factory.hpp
Text files modified: 
   sandbox/boost/extension/convenience.hpp      |    44 ---                                     
   sandbox/boost/extension/factory.hpp          |   476 +++++---------------------------------- 
   sandbox/boost/extension/factory_map.hpp      |   470 ++++----------------------------------- 
   sandbox/boost/extension/registry.hpp         |   104 --------                                
   sandbox/boost/extension/shared_library.hpp   |   377 -------------------------------         
   sandbox/libs/extension/test/Jamfile.v2       |    21 +                                       
   sandbox/libs/extension/test/construction.cpp |   120 +++++++++                               
   7 files changed, 235 insertions(+), 1377 deletions(-)

Added: sandbox/boost/extension/common.hpp
==============================================================================
--- (empty file)
+++ sandbox/boost/extension/common.hpp	2007-09-04 23:56:48 EDT (Tue, 04 Sep 2007)
@@ -0,0 +1,25 @@
+/*
+ * Boost.Extension / common:
+ *         common include files
+ *
+ * (C) Copyright Jeremy Pack 2007
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org/ for latest version.
+ */
+
+#ifndef BOOST_EXTENSION_COMMON_HPP
+#define BOOST_EXTENSION_COMMON_HPP
+
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/if.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/repetition.hpp>
+
+#ifndef BOOST_EXTENSION_MAX_FUNCTOR_PARAMS
+#define BOOST_EXTENSION_MAX_FUNCTOR_PARAMS 6
+#endif // BOOST_EXTENSION_MAX_FUNCTOR_PARAMS
+
+#endif // BOOST_EXTENSION_COMMON_HPP

Modified: sandbox/boost/extension/convenience.hpp
==============================================================================
--- sandbox/boost/extension/convenience.hpp	(original)
+++ sandbox/boost/extension/convenience.hpp	2007-09-04 23:56:48 EDT (Tue, 04 Sep 2007)
@@ -1,44 +0,0 @@
-/*
- * Boost.Extension / convenience functions:
- *         for now only one to load a library and register it in the factory 
- *         map.
- *
- * (C) Copyright Jeremy Pack 2007
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE_1_0.txt or copy at
- * http://www.boost.org/LICENSE_1_0.txt)
- *
- * See http://www.boost.org/ for latest version.
- */
-
-#ifndef BOOST_EXTENSION_CONVENIENCE_HPP
-#define BOOST_EXTENSION_CONVENIENCE_HPP
-
-#include <boost/extension/factory_map.hpp>
-
-namespace boost{namespace extensions{
-  
-inline void load_single_library(factory_map & current_zone, 
-                                const char * library_path, 
-                                const char * external_function_name)
-{
-  shared_library lib(library_path);
-  if (!lib.open())
-  {
-    return;
-  }
-  functor<void, factory_map &> load_func = 
-    lib.get_functor<void, factory_map &>(external_function_name);
-
-  if (!load_func.is_valid())
-  {
-    return;
-  }
-  load_func(current_zone);
-}
-
-}}
-
-
-
-#endif

Deleted: sandbox/boost/extension/counted_factory.hpp
==============================================================================
--- sandbox/boost/extension/counted_factory.hpp	2007-09-04 23:56:48 EDT (Tue, 04 Sep 2007)
+++ (empty file)
@@ -1,727 +0,0 @@
-/*
- * Boost.Extension / counted factory:
- *         factory to register the implementations and create them 
- *        (with a reference count)
- *
- * (C) Copyright Jeremy Pack 2007
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE_1_0.txt or copy at
- * http://www.boost.org/LICENSE_1_0.txt)
- *
- * See http://www.boost.org/ for latest version.
- */
-
-#ifndef BOOST_EXTENSION_COUNTED_FACTORY_HPP
-#define BOOST_EXTENSION_COUNTED_FACTORY_HPP
-#include <string>
-
-#ifdef BOOST_EXTENSION_USE_PP
-
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/if.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/repetition.hpp>
-
-#ifndef BOOST_EXTENSION_MAX_FUNCTOR_PARAMS
-#define BOOST_EXTENSION_MAX_FUNCTOR_PARAMS 6
-#endif
-
-#endif
-
-namespace boost{namespace extensions{
-
-#ifdef BOOST_EXTENSION_USE_PP
-
-/// Declaration of functor class template.
-template <class Interface, class Info,
-    BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_INC(\
-                                        BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
-                                        class Param, void)>\
-                                             class counted_factory;
-/**/
-
-
-#define BOOST_EXTENSION_COUNTED_FACTORY_CLASS(Z, N, _) \
-template<class Interface, class Info BOOST_PP_COMMA_IF(N) \
-         BOOST_PP_ENUM_PARAMS(N, class Param) > \
-class counted_factory<Interface, Info BOOST_PP_COMMA_IF(N) \
-              BOOST_PP_ENUM_PARAMS(N, Param) > { \
-protected: \
-  int * counter_; \
-  std::string library_; \
-  class generic_factory_function \
-  { \
-  public: \
-    virtual ~generic_factory_function(){} \
-    virtual Interface * operator()(int * counter \
-             BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(N, Param) ) = 0; \
-    virtual generic_factory_function * copy() const = 0; \
-  }; \
-  template <class T> \
-  class factory_function : public generic_factory_function \
-  { \
-  public: \
-    class counted_object : public T \
-    { \
-    private: \
-      int * counter_; \
-    public: \
-      counted_object(int * counter BOOST_PP_COMMA_IF(N) \
-                     BOOST_PP_ENUM_BINARY_PARAMS(N, Param, p)) \
-                             : T(BOOST_PP_ENUM_PARAMS(N, p)), \
-                               counter_(counter) \
-      { \
-        ++(*counter_); \
-      } \
-      ~counted_object() \
-      { \
-        --(*counter_); \
-      } \
-    }; \
-    virtual ~factory_function(){} \
-    virtual Interface * operator() \
-      (int * counter BOOST_PP_COMMA_IF(N) \
-       BOOST_PP_ENUM_BINARY_PARAMS(N, Param, p)) \
-    { \
-      return static_cast<Interface*>(new counted_object(counter \
-                                     BOOST_PP_COMMA_IF(N) \
-                                     BOOST_PP_ENUM_PARAMS(N,p)));} \
-    virtual generic_factory_function * copy() const { \
-      return new factory_function<T>; \
-    } \
-  }; \
-  std::auto_ptr<generic_factory_function> factory_func_ptr_; \
-  Info info_; \
-public: \
-  void set_library(const char * library_name) \
-  { \
-    library_ = library_name; \
-  } \
-  void set_counter(int * counter) \
-  { \
-    counter_ = counter; \
-  } \
-  const char * library() \
-  { \
-    return library_.c_str(); \
-  } \
-  template <class Actual> \
-    void set_type_special(Actual *){ \
-    factory_func_ptr_.reset(new factory_function<Actual>());} \
-  template <class Actual> \
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();} \
-  counted_factory(Info info) \
-    :factory_func_ptr_(0), \
-    info_(info) \
-  {} \
-  counted_factory(const counted_factory & first) \
-    :counter_(first.counter_), \
-    library_(first.library_), \
-    factory_func_ptr_(first.factory_func_ptr_->copy()), \
-    info_(first.info_) \
-                       {} \
-  Interface * operator()(int * counter BOOST_PP_COMMA_IF(N) \
-                         BOOST_PP_ENUM_BINARY_PARAMS(N, Param, p)) \
-  {return create(counter BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(N, p));} \
-  Interface * create(BOOST_PP_ENUM_BINARY_PARAMS(N, Param, p)) { \
-    return (*factory_func_ptr_) (counter_ BOOST_PP_COMMA_IF(N) \
-                                 BOOST_PP_ENUM_PARAMS(N, p)); \
-  } \
-  Info & get_info(){return info_;} \
-};
-/**/
-
-/// Functor template specializations.
-BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
-                             BOOST_EXTENSION_COUNTED_FACTORY_CLASS, _)
-
-
-#undef BOOST_EXTENSION_COUNTED_FACTORY_CLASS
-#else
-  template <class Interface, class Info, class Param1 = void, 
-            class Param2 = void, class Param3 = void, class Param4 = void, 
-            class Param5 = void, class Param6 = void>
-class counted_factory
-{
-protected:
-  int * counter_;
-  std::string library_;
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(int * counter, Param1, Param2, Param3, 
-                                   Param4, Param5, Param6) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    class counted_object : public T
-    {
-    private:
-      int * counter_;
-    public:
-      counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3, 
-                     Param4 p4, Param5 p5, Param6 p6) 
-        : T(p1, p2, p3, p4, p5, p6),
-      counter_(counter)
-      {
-        ++(*counter_);
-      }
-      ~counted_object()
-      {
-        --(*counter_);
-      }  
-    };
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (int * counter, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, 
-       Param6 p6)
-    {  // A compilation error here usually indicates that the
-       // class you are adding is not derived from the base class
-       // that you indicated.
-      return static_cast<Interface*>(new counted_object(counter, p1, p2, p3, 
-                                                        p4, p5, p6));}
-    virtual generic_factory_function * copy() const 
-    {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  void set_library(const char * library_name)
-  {
-    library_ = library_name;
-  }
-  void set_counter(int * counter)
-  {
-    counter_ = counter;
-  }
-  const char * library()
-  {
-    return library_.c_str();
-  }
-  template <class Actual>
-  void set_type_special(Actual *) {
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-  void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  counted_factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  counted_factory(const counted_factory & first)
-    :counter_(first.counter_),
-    library_(first.library_),
-    factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(int * counter, Param1 p1, Param2 p2, Param3 p3, 
-                         Param4 p4, Param5 p5, Param6 p6)
-    {return create(counter, p1, p2, p3, p4, p5, p6);}
-  Interface * create(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, 
-                     Param6 p6){return (*factory_func_ptr_)
-  (counter_, p1, p2, p3, p4, p5, p6);}
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info, class Param1, class Param2, 
-          class Param3, class Param4, class Param5>
-class counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5>
-{
-protected:
-  int * counter_;
-  std::string library_;
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(int * counter, Param1, Param2, Param3, 
-                                   Param4, Param5) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    class counted_object : public T
-    {
-    private:
-      int * counter_;
-    public:
-      counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3, 
-                     Param4 p4, Param5 p5) : T(p1, p2, p3, p4, p5),
-      counter_(counter)
-      {
-        ++(*counter_);
-      }
-      ~counted_object()
-      {
-        --(*counter_);
-      }  
-    };
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (int * counter, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)
-    {  // A compilation error here usually indicates that the
-       // class you are adding is not derived from the base class
-       // that you indicated.
-      return static_cast<Interface*>(new counted_object(counter, p1, p2, p3, 
-                                                        p4, p5));}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  void set_library(const char * library_name)
-  {
-    library_ = library_name;
-  }
-  void set_counter(int * counter)
-  {
-    counter_ = counter;
-  }
-  const char * library()
-  {
-    return library_.c_str();
-  }
-  template <class Actual>
-    void set_type_special(Actual *){
-    factory_func_ptr_.reset(new factory_function<Actual>());}
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  counted_factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  counted_factory(const counted_factory & first)
-    :counter_(first.counter_),
-    library_(first.library_),
-    factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(int * counter, Param1 p1, Param2 p2, Param3 p3, 
-                         Param4 p4, Param5 p5)
-    {return create(counter, p1, p2, p3, p4, p5);}
-  Interface * create(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) {
-    return (*factory_func_ptr_) (counter_, p1, p2, p3, p4, p5);
-  }
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info, class Param1, class Param2, 
-          class Param3, class Param4>
-class counted_factory<Interface, Info, Param1, Param2, Param3, Param4>
-{
-protected:
-  int * counter_;
-  std::string library_;
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(int * counter, Param1, Param2, Param3, 
-                                   Param4) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    class counted_object : public T
-    {
-    private:
-      int * counter_;
-    public:
-      counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3, 
-                     Param4 p4) : T(p1, p2, p3, p4),
-      counter_(counter)
-      {
-        ++(*counter_);
-      }
-      ~counted_object()
-      {
-        --(*counter_);
-      }  
-    };
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (int * counter, Param1 p1, Param2 p2, Param3 p3, Param4 p4)
-    {  // A compilation error here usually indicates that the
-       // class you are adding is not derived from the base class
-       // that you indicated.
-      return static_cast<Interface*>(new counted_object(counter, p1, p2, p3, 
-                                                        p4));}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  void set_library(const char * library_name)
-  {
-    library_ = library_name;
-  }
-  void set_counter(int * counter)
-  {
-    counter_ = counter;
-  }
-  const char * library()
-  {
-    return library_.c_str();
-  }
-  template <class Actual>
-  void set_type_special(Actual *){
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  counted_factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  counted_factory(const counted_factory & first)
-    :counter_(first.counter_),
-    library_(first.library_),
-    factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(int * counter, Param1 p1, Param2 p2, Param3 p3, 
-                         Param4 p4)
-    {return create(counter, p1, p2, p3, p4);}
-  Interface * create(Param1 p1, Param2 p2, Param3 p3, Param4 p4) {
-    return (*factory_func_ptr_) (counter_, p1, p2, p3, p4);
-  }
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info, class Param1, class Param2, 
-          class Param3>
-class counted_factory<Interface, Info, Param1, Param2, Param3>
-{
-protected:
-  int * counter_;
-  std::string library_;
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(int * counter, Param1, Param2, Param3) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    class counted_object : public T
-    {
-    private:
-      int * counter_;
-    public:
-      counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3) 
-        : T(p1, p2, p3),
-      counter_(counter)
-      {
-        ++(*counter_);
-      }
-      ~counted_object()
-      {
-        --(*counter_);
-      }  
-    };
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (int * counter, Param1 p1, Param2 p2, Param3 p3)
-    {  // A compilation error here usually indicates that the
-       // class you are adding is not derived from the base class
-       // that you indicated.
-      return static_cast<Interface*>(new counted_object(counter, p1, p2, p3));}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  void set_library(const char * library_name)
-  {
-    library_ = library_name;
-  }
-  void set_counter(int * counter)
-  {
-    counter_ = counter;
-  }
-  const char * library()
-  {
-    return library_.c_str();
-  }
-  template <class Actual>
-    void set_type_special(Actual *){
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  counted_factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  counted_factory(const counted_factory & first)
-    :counter_(first.counter_),
-    library_(first.library_),
-    factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(int * counter, Param1 p1, Param2 p2, Param3 p3)
-    {return create(counter, p1, p2, p3);}
-  Interface * create(Param1 p1, Param2 p2, Param3 p3){
-    return (*factory_func_ptr_) (counter_, p1, p2, p3);
-  }
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info, class Param1, class Param2>
-class counted_factory<Interface, Info, Param1, Param2>
-{
-protected:
-  int * counter_;
-  std::string library_;
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(int * counter, Param1, Param2) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    class counted_object : public T
-    {
-    private:
-      int * counter_;
-    public:
-      counted_object(int * counter, Param1 p1, Param2 p2) : T(p1, p2),
-      counter_(counter)
-      {
-        ++(*counter_);
-      }
-      ~counted_object()
-      {
-        --(*counter_);
-      }  
-    };
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (int * counter, Param1 p1, Param2 p2)
-    {  // A compilation error here usually indicates that the
-       // class you are adding is not derived from the base class
-       // that you indicated.
-      return static_cast<Interface*>(new counted_object(counter, p1, p2));}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  void set_library(const char * library_name)
-  {
-    library_ = library_name;
-  }
-  void set_counter(int * counter)
-  {
-    counter_ = counter;
-  }
-  const char * library()
-  {
-    return library_.c_str();
-  }
-  template <class Actual>
-    void set_type_special(Actual *){
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  counted_factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  counted_factory(const counted_factory & first)
-    :counter_(first.counter_),
-    library_(first.library_),
-    factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(int * counter, Param1 p1, Param2 p2)
-    {return create(counter, p1, p2);}
-  Interface * create(Param1 p1, Param2 p2){return (*factory_func_ptr_)
-  (counter_, p1, p2);}
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info, class Param1>
-class counted_factory<Interface, Info, Param1>
-{
-protected:
-  int * counter_;
-  std::string library_;
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(int * counter, Param1) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    class counted_object : public T
-    {
-    private:
-      int * counter_;
-    public:
-      counted_object(int * counter, Param1 p1) : T(p1),
-      counter_(counter)
-      {
-        ++(*counter_);
-      }
-      ~counted_object()
-      {
-        --(*counter_);
-      }  
-    };
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (int * counter, Param1 p1)
-    {  // A compilation error here usually indicates that the
-       // class you are adding is not derived from the base class
-       // that you indicated.
-      return static_cast<Interface*>(new counted_object(counter, p1));}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  void set_library(const char * library_name)
-  {
-    library_ = library_name;
-  }
-  void set_counter(int * counter)
-  {
-    counter_ = counter;
-  }
-  const char * library()
-  {
-    return library_.c_str();
-  }
-  template <class Actual>
-    void set_type_special(Actual *){
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  counted_factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  counted_factory(const counted_factory & first)
-    :counter_(first.counter_),
-    library_(first.library_),
-    factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(int * counter, Param1 p1)
-    {return create(counter, p1);}
-  Interface * create(Param1 p1){return (*factory_func_ptr_)
-  (counter_, p1);}
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info>
-class counted_factory<Interface, Info>
-{
-protected:
-  int * counter_;
-  std::string library_;
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(int * counter) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    class counted_object : public T
-    {
-    private:
-      int * counter_;
-    public:
-      counted_object(int * counter) : T(),
-      counter_(counter)
-      {
-        ++(*counter_);
-      }
-      ~counted_object()
-      {
-        --(*counter_);
-      }  
-    };
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (int * counter)
-    {  // A compilation error here usually indicates that the
-       // class you are adding is not derived from the base class
-       // that you indicated.
-      return static_cast<Interface*>(new counted_object(counter));}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  void set_library(const char * library_name)
-  {
-    library_ = library_name;
-  }
-  void set_counter(int * counter)
-  {
-    counter_ = counter;
-  }
-  const char * library()
-  {
-    return library_.c_str();
-  }
-  template <class Actual>
-    void set_type_special(Actual *){
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  counted_factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  counted_factory(const counted_factory & first)
-    :counter_(first.counter_),
-    library_(first.library_),
-    factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(int * counter)
-    {return create(counter);}
-  Interface * create(){return (*factory_func_ptr_)
-  (counter_);}
-  Info & get_info(){return info_;}
-};
-#endif // BOOST_EXTENSION_USE_PP
-}}
-#endif

Modified: sandbox/boost/extension/factory.hpp
==============================================================================
--- sandbox/boost/extension/factory.hpp	(original)
+++ sandbox/boost/extension/factory.hpp	2007-09-04 23:56:48 EDT (Tue, 04 Sep 2007)
@@ -13,432 +13,76 @@
 #ifndef BOOST_EXTENSION_FACTORY_HPP
 #define BOOST_EXTENSION_FACTORY_HPP
 
-#include <string>
-
-#ifdef BOOST_EXTENSION_USE_PP
-
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/if.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/repetition.hpp>
-
-#ifndef BOOST_EXTENSION_MAX_FUNCTOR_PARAMS
-#define BOOST_EXTENSION_MAX_FUNCTOR_PARAMS 6
-#endif
-
-#endif
+#include <boost/extension/common.hpp>
 
 namespace boost{namespace extensions{
+template <class T, class D
+          BOOST_PP_COMMA_IF(BOOST_EXTENSION_MAX_FUNCTOR_PARAMS)
+          BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_INC(\
+          BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
+          class Param, void) >
+  class create_function;
+  
+#define BOOST_EXTENSION_CREATE_FUNCTION_CLASS(Z, N, _) \
+template <class T, class D BOOST_PP_COMMA_IF(N) \
+          BOOST_PP_ENUM_PARAMS(N, \
+          class Param) > \
+class create_function<T, D BOOST_PP_COMMA_IF(N) \
+                      BOOST_PP_ENUM_PARAMS(N, \
+                     Param) > \
+{ \
+public: \
+  static T * create(BOOST_PP_ENUM_BINARY_PARAMS(N, Param, p)) { \
+    return new D(BOOST_PP_ENUM_PARAMS(N, p)); \
+  } \
+};
 
-#ifdef BOOST_EXTENSION_USE_PP
-
-/// Declaration of functor class template.
-template <class Interface, class Info,
-    BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_INC(\
-                                        BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
-                                        class Param, void)> class factory;
-
-
+template <class T
+          BOOST_PP_COMMA_IF(BOOST_EXTENSION_MAX_FUNCTOR_PARAMS)
+          BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_INC(\
+          BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
+          class Param, void) >
+class factory;
 
 #define BOOST_EXTENSION_FACTORY_CLASS(Z, N, _) \
-template<class Interface, class Info BOOST_PP_COMMA_IF(N) \
-         BOOST_PP_ENUM_PARAMS(N, \
-         class Param) > \
-class factory<Interface, Info BOOST_PP_COMMA_IF(N) \
-              BOOST_PP_ENUM_PARAMS(N, Param) > { \
-  protected: \
-    class generic_factory_function \
-    { \
-      public: \
-        virtual ~generic_factory_function(){} \
-            virtual Interface * operator()(BOOST_PP_ENUM_PARAMS(N, Param)) = 0;\
-            virtual generic_factory_function * copy() const = 0; \
-    }; \
-    template <class T> \
-    class factory_function : public generic_factory_function \
-    { \
-      public: \
-        virtual ~factory_function(){} \
-        virtual Interface * operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, Param, p))\
-        { \
-          return new T(BOOST_PP_ENUM_PARAMS(N, p)); \
-        } \
-        virtual generic_factory_function * copy() const \
-        { \
-          return new factory_function<T>; \
-        } \
-    }; \
-    std::auto_ptr<generic_factory_function> factory_func_ptr_; \
-    Info info_; \
-  public: \
-    template <class Actual> \
-  void set_type_special(Actual *) { \
-    factory_func_ptr_.reset(new factory_function<Actual>()); \
+template <class T BOOST_PP_COMMA_IF(N) \
+          BOOST_PP_ENUM_PARAMS(N, \
+          class Param) > \
+class factory <T BOOST_PP_COMMA_IF(N) \
+               BOOST_PP_ENUM_PARAMS(N, \
+               Param) > \
+{ \
+public: \
+  template <class D> \
+  void set() { \
+    func_ = &create_function<T, D BOOST_PP_COMMA_IF(N) \
+    BOOST_PP_ENUM_PARAMS(N, \
+    Param)>::create; \
   } \
-  template <class Actual> \
-    void set_type(){ \
-      factory_func_ptr_ = new factory_function<Actual>(); \
-    } \
-    factory(Info info) :factory_func_ptr_(0), info_(info) {} \
-    factory(const factory & first) \
-      :factory_func_ptr_(first.factory_func_ptr_->copy()), info_(first.info_){} \
-    Interface * operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, Param, p)) \
-    { \
-      return create(BOOST_PP_ENUM_PARAMS(N, p)); \
-    } \
-    Interface * create(BOOST_PP_ENUM_BINARY_PARAMS(N, Param, p)) \
-    { \
-      return (*factory_func_ptr_) (BOOST_PP_ENUM_PARAMS(N, p)); \
+  factory() : func_(0) {} \
+  factory(const factory<T> & first) : func_(first.func_) {} \
+  factory & operator=(const factory<T> & first) { \
+    func_ = first->func_; \
+    return *this; \
+  } \
+  bool is_valid() {return func_ != 0;} \
+  T * create(BOOST_PP_ENUM_BINARY_PARAMS(N, Param, p)) { \
+    if (func_) { \
+      return func_(BOOST_PP_ENUM_PARAMS(N, p)); \
+    } else { \
+      return 0; \
     } \
-    Info & get_info(){return info_;} \
+  } \
+private: \
+  T * (*func_)(BOOST_PP_ENUM_PARAMS(N, Param)); \
 };
-/**/
 
-
-/// Functor template specializations.
 BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
-                             BOOST_EXTENSION_FACTORY_CLASS, _)
-
+                BOOST_EXTENSION_CREATE_FUNCTION_CLASS, _)
+BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
+                BOOST_EXTENSION_FACTORY_CLASS, _)
 #undef BOOST_EXTENSION_FACTORY_CLASS
-#else
-
-  template <class Interface, class Info, class Param1 = void, 
-            class Param2 = void, class Param3 = void, class Param4 = void, 
-            class Param5 = void, class Param6 = void>
-class factory
-{
-protected:
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(Param1, Param2, Param3, Param4, Param5, 
-                                   Param6) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)
-    {return new T(p1, p2, p3, p4, p5, p6);}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  template <class Actual>
-  void set_type_special(Actual *) {
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  factory(const factory & first)
-    :factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, 
-                         Param5 p5, Param6 p6)
-    {return create(p1, p2, p3, p4, p5, p6);}
-  Interface * create(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, 
-                     Param6 p6)
-  {
-    return (*factory_func_ptr_) (p1, p2, p3, p4, p5, p6);
-  }
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info, class Param1, class Param2, 
-          class Param3, class Param4, class Param5>
-class factory<Interface, Info, Param1, Param2, Param3, Param4, Param5>
-{
-protected:
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(Param1, Param2, Param3, Param4, Param5) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)
-    {return new T(p1, p2, p3, p4, p5);}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  template <class Actual>
-  void set_type_special(Actual *) {
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  factory(const factory & first)
-    :factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)
-    {return create(p1, p2, p3, p4, p5);}
-  Interface * create(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) {
-    return (*factory_func_ptr_) (p1, p2, p3, p4, p5);
-  }
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info, class Param1, class Param2, 
-          class Param3, class Param4>
-class factory<Interface, Info, Param1, Param2, Param3, Param4>
-{
-protected:
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(Param1, Param2, Param3, Param4) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (Param1 p1, Param2 p2, Param3 p3, Param4 p4)
-    {return new T(p1, p2, p3, p4);}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  template <class Actual>
-  void set_type_special(Actual *) {
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  factory(const factory & first)
-    :factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4)
-    {return create(p1, p2, p3, p4);}
-  Interface * create(Param1 p1, Param2 p2, Param3 p3, Param4 p4) {
-    return (*factory_func_ptr_) (p1, p2, p3, p4);
-  }
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info, class Param1, class Param2, 
-          class Param3>
-class factory<Interface, Info, Param1, Param2, Param3>
-{
-protected:
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(Param1, Param2, Param3) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (Param1 p1, Param2 p2, Param3 p3)
-    {return new T(p1, p2, p3);}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  template <class Actual>
-  void set_type_special(Actual *) {
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  factory(const factory & first)
-    :factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(Param1 p1, Param2 p2, Param3 p3)
-    {return create(p1, p2, p3);}
-  Interface * create(Param1 p1, Param2 p2, Param3 p3) {
-    return (*factory_func_ptr_) (p1, p2, p3);
-  }
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info, class Param1, class Param2>
-class factory<Interface, Info, Param1, Param2>
-{
-protected:
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(Param1, Param2) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (Param1 p1, Param2 p2)
-    {return new T(p1, p2);}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  template <class Actual>
-  void set_type_special(Actual *) {
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  factory(const factory & first)
-    :factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(Param1 p1, Param2 p2)
-    {return create(p1, p2);}
-  Interface * create(Param1 p1, Param2 p2){return (*factory_func_ptr_)
-  (p1, p2);}
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info, class Param1>
-class factory<Interface, Info, Param1>
-{
-protected:
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()(Param1) = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      (Param1 p1)
-    {return new T(p1);}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  template <class Actual>
-    void set_type_special(Actual *) {
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  factory(const factory & first)
-    :factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()(Param1 p1)
-    {return create(p1);}
-  Interface * create(Param1 p1){return (*factory_func_ptr_)
-  (p1);}
-  Info & get_info(){return info_;}
-};
-template <class Interface, class Info>
-class factory<Interface, Info>
-{
-protected:
-  class generic_factory_function
-  {
-  public:
-    virtual ~generic_factory_function(){}
-    virtual Interface * operator()() = 0;
-    virtual generic_factory_function * copy() const = 0;
-  };
-  template <class T>
-  class factory_function : public generic_factory_function
-  {
-  public:
-    virtual ~factory_function(){}
-    virtual Interface * operator()
-      ()
-    {return new T();}
-    virtual generic_factory_function * copy() const {
-      return new factory_function<T>;
-    }
-  };
-  std::auto_ptr<generic_factory_function> factory_func_ptr_;
-  Info info_;
-public:
-  template <class Actual>
-    void set_type_special(Actual *) {
-    factory_func_ptr_.reset(new factory_function<Actual>());
-  }
-  template <class Actual>
-    void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
-  factory(Info info)
-    :factory_func_ptr_(0),
-    info_(info)
-  {}
-  factory(const factory & first)
-    :factory_func_ptr_(first.factory_func_ptr_->copy()),
-    info_(first.info_)
-                       {}
-  Interface * operator()()
-    {return create();}
-  Interface * create(){return (*factory_func_ptr_)
-  ();}
-  Info & get_info(){return info_;}
-};
-#endif // BOOST_EXTENSION_USE_PP
+#undef BOOST_EXTENSION_CREATE_FUNCTION_CLASS
 }}
 
-
-#endif
+#endif // BOOST_EXTENSION_FACTORY_HPP

Modified: sandbox/boost/extension/factory_map.hpp
==============================================================================
--- sandbox/boost/extension/factory_map.hpp	(original)
+++ sandbox/boost/extension/factory_map.hpp	2007-09-04 23:56:48 EDT (Tue, 04 Sep 2007)
@@ -12,436 +12,70 @@
 
 #ifndef BOOST_EXTENSION_FACTORY_MAP_HPP
 #define BOOST_EXTENSION_FACTORY_MAP_HPP
-#include <list>
-#include <memory>
 #include <map>
 #include <boost/extension/factory.hpp>
-#include <boost/extension/extension.hpp>
-#include  <boost/extension/impl/typeinfo.hpp>
-
-#ifdef BOOST_EXTENSION_USE_PP
-
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/if.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/repetition.hpp>
-
-#ifndef BOOST_EXTENSION_MAX_FUNCTOR_PARAMS
-#define BOOST_EXTENSION_MAX_FUNCTOR_PARAMS 6
-#endif
-
-#endif
-
+#include <boost/extension/impl/typeinfo.hpp>
 
 namespace boost{namespace extensions{
 
-
-template <class TypeInfo>
-class basic_factory_map
-{
-protected:
-  class generic_factory_container
-  {
-  public:
-    virtual ~generic_factory_container(){}
-  };
-  template <class Interface, class Info, class Param1 = void, 
-            class Param2 = void, class Param3 = void, class Param4 = void, 
-            class Param5 = void, class Param6 = void>
-  class factory_container : public std::list<factory<Interface, Info, Param1, 
-                                                     Param2, Param3, Param4, 
-                                                     Param5, Param6> >, 
-                            public generic_factory_container
-  {
-  public:
-      factory_container() {}
-     // factory_container(basic_factory_map & z)
-      //  :std::list<factory<Interface, Info, Param1, Param2, Param3, Param4, 
-    // Param5, Param6> >(z.get<Interface, Param1, Param2, Param3, Param4, 
-    // Param5, Param6>()){}
-      virtual ~factory_container(){}
-    
-   // factory_container() {}
-   // factory_container(basic_factory_map & z)
-    //  :std::list<factory<Interface, Info, Param1, Param2, Param3, Param4, 
-    // Param5, Param6> >(z.get<Interface, Param1, Param2, Param3, Param4,
-    // Param5, Param6>()){}
-    //virtual ~factory_container(){}
-  };
-  typedef std::map<TypeInfo, generic_factory_container *> FactoryMap;
-  FactoryMap factories_; 
-public:
-  ~basic_factory_map(){
-    for(typename FactoryMap::iterator it = factories_.begin(); 
-        it != factories_.end(); ++it)
-      delete it->second;
-    //TODO - test for memory leaks.
-  }
-#ifdef BOOST_EXTENSION_USE_PP
-
-#define BOOST_EXTENSION_FACTORY_MAP_OPERATOR_LIST(Z, N, _) \
-template<class Interface, class Info BOOST_PP_COMMA_IF(N) \
-         BOOST_PP_ENUM_PARAMS(N, \
-         class Param) > \
-operator std::list<factory<Interface, Info BOOST_PP_COMMA_IF(N)        \
-         BOOST_PP_ENUM_PARAMS(N, Param) > > & () { \
-  return this->get<Interface, Info BOOST_PP_COMMA_IF(N) \
-                   BOOST_PP_ENUM_PARAMS(N, Param) >(); \
-}
-/**/
-
-#define BOOST_EXTENSION_FACTORY_MAP_GET_METHOD(Z, N, _) \
-template <class Interface, class Info BOOST_PP_COMMA_IF(N) \
+#define BOOST_EXTENSION_FACTORY_MAP_GET_FUNCTION(Z, N, _) \
+template <class Interface, class Info \
+          BOOST_PP_COMMA_IF(N) \
           BOOST_PP_ENUM_PARAMS(N, class Param) > \
-std::list<factory<Interface, Info BOOST_PP_COMMA_IF(N) \
-          BOOST_PP_ENUM_PARAMS(N, Param) > > & get() \
-{ \
-  TypeInfo current_type = \
-    type_info_handler<TypeInfo, factory<Interface, Info BOOST_PP_COMMA_IF(N) \
-      BOOST_PP_ENUM_PARAMS(N, Param) > >::get_class_type(); \
-  typename FactoryMap::iterator it = factories_.find(current_type); \
-  if (it == factories_.end()) \
-  { \
-    factory_container<Interface, Info BOOST_PP_COMMA_IF(N) \
-      BOOST_PP_ENUM_PARAMS(N, Param) > * ret = \
-            new factory_container<Interface, Info BOOST_PP_COMMA_IF(N) \
-            BOOST_PP_ENUM_PARAMS(N, Param) >(); \
-    factories_[current_type] = ret; \
-    return *ret; \
-  } \
-  else \
-  { \
-    return static_cast<factory_container<Interface, Info BOOST_PP_COMMA_IF(N) \
-                       BOOST_PP_ENUM_PARAMS(N, Param) > &>(*(it->second)); \
+std::map<Info, \
+  factory<Interface  BOOST_PP_COMMA_IF(N) \
+  BOOST_PP_ENUM_PARAMS(N, Param)> > & get() { \
+  TypeInfo t = type_info_handler<TypeInfo, \
+    Interface *(*)(BOOST_PP_ENUM_PARAMS(N, Param))> \
+  ::get_class_type(); \
+  typename std::map<TypeInfo, generic_map_holder*>::iterator it = \
+    maps_.find(t); \
+  map_holder<std::map<Info, \
+    factory<Interface BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(N, Param)> > > \
+      * holder; \
+  if (it == maps_.end()) { \
+    holder = new map_holder<std::map<Info, \
+      factory<Interface BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(N, Param)> > >; \
+    it = maps_.insert(std::make_pair \
+                      (t, holder)).first; \
+  } else { \
+    holder = \
+    static_cast<map_holder<std::map<Info, \
+      factory<Interface  BOOST_PP_COMMA_IF(N) \
+              BOOST_PP_ENUM_PARAMS(N, Param)> > > *> \
+    (it->second); \
   } \
+  return *static_cast<std::map<Info, \
+    factory<Interface BOOST_PP_COMMA_IF(N) \
+            BOOST_PP_ENUM_PARAMS(N, Param)> > * >(holder); \
 }
-/**/
-
-
-#define BOOST_EXTENSION_FACTORY_MAP_ADD_METHOD(Z, N, _) \
-template <class Actual, class Interface, class Info BOOST_PP_COMMA_IF(N) \
-          BOOST_PP_ENUM_PARAMS(N, class Param) > \
-void add(Info info) \
-{ \
-  typedef std::list<factory<Interface, Info BOOST_PP_COMMA_IF(N) \
-                    BOOST_PP_ENUM_PARAMS(N, Param) > > ListType; \
-  ListType & s = this->get<Interface, Info BOOST_PP_COMMA_IF(N) \
-                           BOOST_PP_ENUM_PARAMS(N, Param) >(); \
-  factory<Interface, Info BOOST_PP_COMMA_IF(N) \
-          BOOST_PP_ENUM_PARAMS(N, Param) > f(info); \
-    f.set_type_special((Actual*)0); \
-    s.push_back(f); \
-}
-/**/
-
-
-BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
-                             BOOST_EXTENSION_FACTORY_MAP_OPERATOR_LIST, _)
-
-
-BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
-                             BOOST_EXTENSION_FACTORY_MAP_GET_METHOD, _)
-
 
+  
+template <class TypeInfo>
+class basic_factory_map {
+public:
 BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
-                             BOOST_EXTENSION_FACTORY_MAP_ADD_METHOD, _)
-
-
-#undef BOOST_EXTENSION_FACTORY_MAP_OPERATOR_LIST
-#undef BOOST_EXTENSION_FACTORY_MAP_GET_METHOD
-#undef BOOST_EXTENSION_FACTORY_MAP_ADD_METHOD
-#else
-  template <class Interface, class Info>
-operator std::list<factory<Interface, Info> > & ()
-  {return this->get<Interface, Info>();}
-  template <class Interface, class Info>
-std::list<factory<Interface, Info> > & get()
-  {
-      TypeInfo current_type = 
-         type_info_handler<TypeInfo, 
-      factory<Interface, Info> >::get_class_type();
-      typename FactoryMap::iterator it = factories_.find(current_type);
-      
-      if (it == factories_.end())
-      {
-        factory_container<Interface, Info> * ret = 
-          new factory_container<Interface, Info>();
-        factories_[current_type] = ret;
-        return *ret;
-      }
-      else
-      {
-        // Change to dynamic if this fails
-        return static_cast<factory_container<Interface, 
-          Info> &>(*(it->second));
-      }
-  }
-template <class Actual, class Interface, class Info>
-void add(Info info)
-  {
-    typedef std::list<factory<Interface, Info> > ListType;
-    ListType & s = this->get<Interface, Info>();
-    factory<Interface, Info> f(info);
-    //f.set_type<Actual>();
-    f.set_type_special((Actual*)0);
-    s.push_back(f);
-    //it->set_type<Actual>(); 
-  }
-  template <class Interface, class Info, class Param1>
-operator std::list<factory<Interface, Info, Param1> > & ()
-  {return this->get<Interface, Info, Param1>();}
-  template <class Interface, class Info, class Param1>
-std::list<factory<Interface, Info, Param1> > & get()
-  {
-      TypeInfo current_type = type_info_handler<TypeInfo, 
-      factory<Interface, Info, Param1> >::get_class_type();
-      typename FactoryMap::iterator it = 
-        factories_.find(current_type);
-      
-      if (it == factories_.end())
-      {
-        factory_container<Interface, Info, Param1> * ret = 
-          new factory_container<Interface, Info, Param1>();
-        factories_[current_type] = ret;
-        return *ret;
-      }
-      else
-      {
-        // Change to dynamic if this fails
-        return static_cast<factory_container<Interface, 
-          Info, Param1> &>(*(it->second));
-      }
-  }
-template <class Actual, class Interface, class Info, class Param1>
-void add(Info info)
-  {
-    typedef std::list<factory<Interface, Info, Param1> > ListType;
-    ListType & s = this->get<Interface, Info, Param1>();
-    factory<Interface, Info, Param1> f(info);
-    //f.set_type<Actual>();
-    f.set_type_special((Actual*)0);
-    s.push_back(f);
-    //it->set_type<Actual>(); 
-  }
-  template <class Interface, class Info, class Param1, class Param2>
-operator std::list<factory<Interface, Info, Param1, Param2> > & ()
-  {return this->get<Interface, Info, Param1, Param2>();}
-  template <class Interface, class Info, class Param1, class Param2>
-std::list<factory<Interface, Info, Param1, Param2> > & get()
-  {
-      TypeInfo current_type = 
-         type_info_handler<TypeInfo, factory<Interface, Info, Param1, 
-      Param2> >::get_class_type();
-      typename FactoryMap::iterator it = 
-        factories_.find(current_type);
-      
-      if (it == factories_.end())
-      {
-        factory_container<Interface, Info, Param1, Param2> * ret = 
-          new factory_container<Interface, Info, Param1, Param2>();
-        factories_[current_type] = ret;
-        return *ret;
-      }
-      else
-      {
-        // Change to dynamic if this fails
-        return static_cast<factory_container<Interface, Info, Param1, 
-          Param2> &>(*(it->second));
-      }
-  }
-template <class Actual, class Interface, class Info, class Param1, 
-          class Param2>
-void add(Info info)
-  {
-    typedef std::list<factory<Interface, Info, Param1, Param2> > ListType;
-    ListType & s = this->get<Interface, Info, Param1, Param2>();
-    factory<Interface, Info, Param1, Param2> f(info);
-    //f.set_type<Actual>();
-    f.set_type_special((Actual*)0);
-    s.push_back(f);
-    //it->set_type<Actual>(); 
-  }
-  template <class Interface, class Info, class Param1, class Param2, 
-            class Param3>
-operator std::list<factory<Interface, Info, Param1, Param2, Param3> > & ()
-  {return this->get<Interface, Info, Param1, Param2, Param3>();}
-  template <class Interface, class Info, class Param1, class Param2, 
-            class Param3>
-std::list<factory<Interface, Info, Param1, Param2, Param3> > & get()
-  {
-      TypeInfo current_type = 
-         type_info_handler<TypeInfo, factory<Interface, Info, Param1, Param2, 
-      Param3> >::get_class_type();
-      typename FactoryMap::iterator it = factories_.find(current_type);
-      
-      if (it == factories_.end())
-      {
-        factory_container<Interface, Info, Param1, Param2, Param3> * ret = 
-          new factory_container<Interface, Info, Param1, Param2, Param3>();
-        factories_[current_type] = ret;
-        return *ret;
-      }
-      else
-      {
-        // Change to dynamic if this fails
-        return static_cast<factory_container<Interface, Info, Param1, Param2, 
-          Param3> &>(*(it->second));
-      }
-  }
-template <class Actual, class Interface, class Info, class Param1, 
-          class Param2, class Param3>
-void add(Info info)
-  {
-    typedef std::list<factory<Interface, Info, Param1, Param2, 
-      Param3> > ListType;
-    ListType & s = this->get<Interface, Info, Param1, Param2, Param3>();
-    factory<Interface, Info, Param1, Param2, Param3> f(info);
-    //f.set_type<Actual>();
-    f.set_type_special((Actual*)0);
-    s.push_back(f);
-    //it->set_type<Actual>(); 
-  }
-  template <class Interface, class Info, class Param1, class Param2, 
-            class Param3, class Param4>
-operator std::list<factory<Interface, Info, Param1, Param2, Param3, 
-                           Param4> > & ()
-  {return this->get<Interface, Info, Param1, Param2, Param3, Param4>();}
-  template <class Interface, class Info, class Param1, class Param2, 
-            class Param3, class Param4>
-std::list<factory<Interface, Info, Param1, Param2, Param3, Param4> > & get()
-  {
-      TypeInfo current_type = 
-         type_info_handler<TypeInfo, factory<Interface, Info, Param1, Param2, 
-      Param3, Param4> >::get_class_type();
-      typename FactoryMap::iterator it = factories_.find(current_type);
-      
-      if (it == factories_.end())
-      {
-        factory_container<Interface, Info, Param1, Param2, Param3, 
-          Param4> * ret = new factory_container<Interface, Info, Param1, 
-          Param2, Param3, Param4>();
-        factories_[current_type] = ret;
-        return *ret;
-      }
-      else
-      {
-        // Change to dynamic if this fails
-        return static_cast<factory_container<Interface, Info, Param1, Param2, 
-          Param3, Param4> &>(*(it->second));
-      }
-  }
-template <class Actual, class Interface, class Info, class Param1, class 
-          Param2, class Param3, class Param4>
-void add(Info info)
-  {
-    typedef std::list<factory<Interface, Info, Param1, Param2, Param3, 
-      Param4> > ListType;
-    ListType & s = this->get<Interface, Info, Param1, Param2, Param3, 
-      Param4>();
-    factory<Interface, Info, Param1, Param2, Param3, Param4> f(info);
-    //f.set_type<Actual>();
-    f.set_type_special((Actual*)0);
-    s.push_back(f);
-    //it->set_type<Actual>(); 
-  }
-  template <class Interface, class Info, class Param1, class Param2, 
-            class Param3, class Param4, class Param5>
-operator std::list<factory<Interface, Info, Param1, Param2, Param3, Param4, 
-                           Param5> > & ()
-  {return this->get<Interface, Info, Param1, Param2, Param3, Param4, 
-      Param5>();}
-  template <class Interface, class Info, class Param1, class Param2, 
-            class Param3, class Param4, class Param5>
-std::list<factory<Interface, Info, Param1, Param2, Param3, Param4, 
-                  Param5> > & get()
-  {
-      TypeInfo current_type = 
-         type_info_handler<TypeInfo, factory<Interface, Info, Param1, Param2, 
-      Param3, Param4, Param5> >::get_class_type();
-      typename FactoryMap::iterator it = 
-        factories_.find(current_type);
-      
-      if (it == factories_.end())
-      {
-        factory_container<Interface, Info, Param1, Param2, Param3, Param4, 
-          Param5> * ret = new factory_container<Interface, Info, Param1, 
-          Param2, Param3, Param4, Param5>();
-        factories_[current_type] = ret;
-        return *ret;
-      }
-      else
-      {
-        // Change to dynamic if this fails
-        return static_cast<factory_container<Interface, Info, Param1, Param2, 
-          Param3, Param4, Param5> &>(*(it->second));
-      }
-  }
-template <class Actual, class Interface, class Info, class Param1, class 
-          Param2, class Param3, class Param4, class Param5>
-void add(Info info)
-  {
-    typedef std::list<factory<Interface, Info, Param1, Param2, Param3, 
-      Param4, Param5> > ListType;
-    ListType & s = this->get<Interface, Info, Param1, Param2, Param3, 
-      Param4, Param5>();
-    factory<Interface, Info, Param1, Param2, Param3, Param4, Param5> f(info);
-    //f.set_type<Actual>();
-    f.set_type_special((Actual*)0);
-    s.push_back(f);
-    //it->set_type<Actual>(); 
-  }
-  template <class Interface, class Info, class Param1, class Param2, 
-            class Param3, class Param4, class Param5, class Param6>
-  operator std::list<factory<Interface, Info, Param1, Param2, Param3, 
-                             Param4, Param5, Param6> > & ()
-  {
-    return this->get<Interface, Info, Param1, Param2, Param3, Param4, 
-      Param5, Param6>();}
-  template <class Interface, class Info, class Param1, class Param2, 
-            class Param3, class Param4, class Param5, class Param6>
-  std::list<factory<Interface, Info, Param1, Param2, Param3, Param4, 
-                    Param5, Param6> > & get()
-  {
-      TypeInfo current_type = type_info_handler<TypeInfo, factory<Interface, 
-      Info, Param1, 
-      Param2, Param3, Param4, Param5, Param6> >::get_class_type();
-      typename FactoryMap::iterator it = 
-        factories_.find(current_type);
-      
-      if (it == factories_.end())
-      {
-        factory_container<Interface, Info, Param1, Param2, Param3, Param4, 
-          Param5, Param6> * ret = new factory_container<Interface, Info, 
-          Param1, Param2, Param3, Param4, Param5, Param6>();
-        factories_[current_type] = ret;
-        return *ret;
-      }
-      else
-      {
-        // Change to dynamic if this fails
-        return static_cast<factory_container<Interface, Info, Param1, Param2, 
-          Param3, Param4, Param5, Param6> &>(*(it->second));
-      }
-  }
-template <class Actual, class Interface, class Info, class Param1, 
-          class Param2, class Param3, class Param4, class Param5, class Param6>
-void add(Info info)
-  {
-    typedef std::list<factory<Interface, Info, Param1, Param2, Param3, 
-      Param4, Param5, Param6> > ListType;
-    ListType & s = this->get<Interface, Info, Param1, Param2, Param3, 
-      Param4, Param5, Param6>();
-    factory<Interface, Info, Param1, Param2, Param3, Param4, Param5, 
-      Param6> f(info);
-    //f.set_type<Actual>();
-    f.set_type_special((Actual*)0);
-    s.push_back(f);
-    //it->set_type<Actual>(); 
+                BOOST_EXTENSION_FACTORY_MAP_GET_FUNCTION, _)
+  ~basic_factory_map() {
+    for (typename std::map<TypeInfo, generic_map_holder*>
+         ::iterator it =maps_.begin();
+         it != maps_.end(); ++it) {
+      delete it->second;
+    }
   }
-#endif // BOOST_EXTENSION_USE_PP
+private:
+  class generic_map_holder {
+  public:
+    virtual ~generic_map_holder() {}
+  };
+  template <class T>
+  class map_holder : public generic_map_holder, public T{
+  };
+  std::map<TypeInfo, generic_map_holder*> maps_;
 };
-
 typedef basic_factory_map<default_type_info> factory_map;
 }}
 
-#endif
+#undef BOOST_EXTENSION_FACTORY_MAP_GET_FUNCTION
+
+#endif
\ No newline at end of file

Modified: sandbox/boost/extension/registry.hpp
==============================================================================
--- sandbox/boost/extension/registry.hpp	(original)
+++ sandbox/boost/extension/registry.hpp	2007-09-04 23:56:48 EDT (Tue, 04 Sep 2007)
@@ -1,104 +0,0 @@
-/*
- * Boost.Extension / registry:
- *         library registration (automates some operations)
- *
- * (C) Copyright Jeremy Pack 2007
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE_1_0.txt or copy at
- * http://www.boost.org/LICENSE_1_0.txt)
- *
- * See http://www.boost.org/ for latest version.
- */
-
-#ifndef BOOST_EXTENSION_REGISTRY_HPP
-#define BOOST_EXTENSION_REGISTRY_HPP
-#include <map>
-#include <string>
-#include <boost/extension/counted_factory_map.hpp>
-#include <boost/extension/shared_library.hpp>
-#include  <boost/extension/impl/typeinfo.hpp>
-namespace boost{namespace extensions{
-template <class TypeInfo>
-class basic_registry : public basic_counted_factory_map<TypeInfo>
-{
-protected:
-  std::map<std::string, std::pair<shared_library, int> > libraries_;
-  typedef std::map<std::string, std::pair<shared_library, int> >::iterator 
-    library_iterator;
-public:
-  ~basic_registry() {
-    for (library_iterator it = libraries_.begin(); it != libraries_.end();)
-    {
-      close((it++)->first.c_str());
-    }
-  }
-  bool clear() {
-    bool ret_val = false;
-    for (library_iterator it = libraries_.begin(); it != libraries_.end();)
-    {
-      if (!it->second.second) {
-        ret_val = true;
-        close((it++)->first.c_str());
-      }    
-      else
-      {
-        ++it;
-      }
-    }
-    return ret_val;
-  }
-  bool open(const char * library_location, const char * function_name = 
-            "boost_extension_registry_function") {
-    library_iterator it = libraries_.find(library_location);
-    if (it == libraries_.end()) {
-      it = libraries_.insert(std::make_pair(std::string(library_location), 
-                             std::make_pair(shared_library(library_location, 
-                                                           false), 
-                                            int(0)))).first;
-      this->current_library_ = library_location;
-      this->current_counter_ = &it->second.second;
-      it->second.first.open();
-      if (it->second.first.is_open() == false) {
-        libraries_.erase(it);
-        return false;
-      }
-      functor<void, counted_factory_map &> load_func = 
-        it->second.first.get_functor<void, counted_factory_map &>
-        (function_name);
-      if (load_func.is_valid())
-      {
-        load_func(*this);
-        return true;
-      }
-      return false;
-    }
-    return false;
-  }
-  bool close(const char * library_location) {
-    // This removes all of the factories from this library
-    library_iterator it = libraries_.find(library_location);
-    if (it == libraries_.end()) 
-      return false;
-    for (typename basic_counted_factory_map<TypeInfo>::FactoryMap::iterator it 
-           = this->factories_.begin(); it != this->factories_.end();) {
-      if(it->second->remove_library(library_location)) 
-      {
-        delete it->second;
-        this->factories_.erase(it++);
-      }
-      else
-      {
-        ++it; 
-      }
-    }
-    it->second.first.close();
-    libraries_.erase(it);
-    return true;
-  }
-  size_t num_libraries() {
-    return libraries_.size(); 
-  }
-};
-typedef basic_registry<default_type_info> registry;
-}}
-#endif

Modified: sandbox/boost/extension/shared_library.hpp
==============================================================================
--- sandbox/boost/extension/shared_library.hpp	(original)
+++ sandbox/boost/extension/shared_library.hpp	2007-09-04 23:56:48 EDT (Tue, 04 Sep 2007)
@@ -1,377 +0,0 @@
-/*
- * Boost.Extension / shared_library:
- *         functions for shared_library loading
- *
- * (C) Copyright Jeremy Pack 2007
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE_1_0.txt or copy at
- * http://www.boost.org/LICENSE_1_0.txt)
- *
- * See http://www.boost.org/ for latest version.
- */
-
-#ifndef BOOST_EXTENSION_LINKED_LIBRARY_HPP
-#define BOOST_EXTENSION_LINKED_LIBRARY_HPP
-#include <boost/extension/impl/library_impl.hpp>
-
-#ifdef BOOST_EXTENSION_USE_BOOST_FUNCTION
-#include <boost/function.hpp>
-#endif
-
-
-#ifdef BOOST_EXTENSION_USE_PP
-
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/if.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/repetition.hpp>
-
-#ifndef BOOST_EXTENSION_MAX_FUNCTOR_PARAMS
-#define BOOST_EXTENSION_MAX_FUNCTOR_PARAMS 6
-#endif
-
-/// functor template specialization macro.
-#define BOOST_EXTENSION_FUNCTOR_CLASS_PREFIX(Z, N, _) \
-template<class ReturnValue BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(N, \
-         class Param) > \
-class functor<ReturnValue BOOST_PP_COMMA_IF(N) \
-      BOOST_PP_ENUM_PARAMS(N, Param) > { \
-  protected:
-/**/
-
-#define BOOST_EXTENSION_FUNCTOR_CLASS_SUFFIX(Z, N, _) \
-    FunctionType func_; \
-  public: \
-    bool is_valid(){return func_ != 0;} \
-    functor(FunctionType func) \
-     : func_(func) {} \
-    functor(generic_function_ptr func) \
-     : func_(FunctionType((ReturnValue (*)(BOOST_PP_ENUM_PARAMS(N, \
-                                           Param))) func)) {} \
-    ReturnValue operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, Param, p)) { \
-      return func_(BOOST_PP_ENUM_PARAMS(N, p)); \
-    } \
-};
-/**/
-
-
-#ifdef BOOST_EXTENSION_USE_BOOST_FUNCTION
-
-#define BOOST_EXTENSION_FUNCTOR_CLASS(Z, N, _) \
-  BOOST_EXTENSION_FUNCTOR_CLASS_PREFIX(Z, N, _) \
-  typedef BOOST_PP_CAT(boost::function, N) \
-     <ReturnValue BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(N, Param) > \
-                                                           FunctionType; \
-  BOOST_EXTENSION_FUNCTOR_CLASS_SUFFIX(Z, N,  _)
-/**/
-
-#else
-
-#define BOOST_EXTENSION_FUNCTOR_CLASS(Z, N, _) \
-  BOOST_EXTENSION_FUNCTOR_CLASS_PREFIX(Z, N, _) \
-  typedef ReturnValue (*FunctionType)(BOOST_PP_ENUM_PARAMS(N, Param)); \
-  BOOST_EXTENSION_FUNCTOR_CLASS_SUFFIX(Z, N,  _)
-/**/
-
-#endif // ifdef BOOST_EXTENSION_USE_BOOST_FUNCTION
-#endif // ifdef BOOST_EXTENSION_USE_PP
-
-
-
-namespace boost{namespace extensions{
-
-#ifdef BOOST_EXTENSION_USE_PP
-
-/// Declaration of functor class template.
-template <class ReturnValue,
-    BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_INC(\
-                  BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), class Param, void)>\
-    class functor;
-
-/// Functor template specializations.
-BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
-                BOOST_EXTENSION_FUNCTOR_CLASS, _)
-
-#undef BOOST_EXTENSION_FUNCTOR_CLASS
-#else
-
-template <class ReturnValue, class Param1 = void, class Param2 = void, 
-          class Param3 = void, class Param4 = void, class Param5 = void, 
-          class Param6 = void>
-class functor
-{
-protected:
-#ifdef BOOST_EXTENSION_USE_BOOST_FUNCTION
-  typedef boost::function6<ReturnValue, Param1, Param2, Param3, 
-                           Param4, Param5, Param6> FunctionType;
-#else
-  typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4, 
-                                      Param5, Param6);
-#endif // BOOST_EXTENSION_USE_BOOST_FUNCTION
-  FunctionType func_;
-public:
-  bool is_valid(){return func_ != 0;}
-  functor(FunctionType func)
-    :func_(func)
-  {}
-  functor(generic_function_ptr func)
-    :func_(FunctionType((ReturnValue (*)(Param1, Param2, Param3, Param4, 
-                                         Param5, Param6)) func))
-  {}
-  ReturnValue operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, 
-                         Param5 p5, Param6 p6)
-  {
-    return func_(p1, p2, p3, p4, p5, p6);
-  }
-};
-
-template <class ReturnValue, class Param1, class Param2, class Param3, 
-          class Param4, class Param5>
-class functor<ReturnValue, Param1, Param2, Param3, Param4, Param5>
-{
-protected:
-#ifdef BOOST_EXTENSION_USE_BOOST_FUNCTION
-  typedef boost::function5<ReturnValue, Param1, Param2, Param3, 
-                           Param4, Param5> FunctionType;
-#else
-  typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4, Param5);
-#endif // BOOST_EXTENSION_USE_BOOST_FUNCTION
-  FunctionType func_;
-public:
-  bool is_valid(){return func_ != 0;}
-  functor(FunctionType func)
-    :func_(func)
-  {}
-  functor(generic_function_ptr func)
-    :func_(FunctionType((ReturnValue (*)(Param1, Param2, Param3, 
-                                         Param4, Param5)) func))
-  {}
-  ReturnValue operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)
-  {
-    return func_(p1, p2, p3, p4, p5);
-  }
-};
-
-template <class ReturnValue, class Param1, class Param2, class Param3, 
-          class Param4>
-class functor<ReturnValue, Param1, Param2, Param3, Param4>
-{
-protected:
-#ifdef BOOST_EXTENSION_USE_BOOST_FUNCTION
-  typedef boost::function4<ReturnValue, Param1, Param2, Param3, 
-                           Param4> FunctionType;
-#else
-  typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4);
-#endif // BOOST_EXTENSION_USE_BOOST_FUNCTION
-  FunctionType func_;
-public:
-  bool is_valid(){return func_ != 0;}
-  functor(FunctionType func)
-    :func_(func)
-  {}
-  functor(generic_function_ptr func)
-    :func_(FunctionType((ReturnValue (*)(Param1, Param2, Param3, 
-                                         Param4)) func))
-  {}
-  ReturnValue operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4)
-  {
-    return func_(p1, p2, p3, p4);
-  }
-};
-
-template <class ReturnValue, class Param1, class Param2, class Param3>
-class functor<ReturnValue, Param1, Param2, Param3>
-{
-protected:
-#ifdef BOOST_EXTENSION_USE_BOOST_FUNCTION
-  typedef boost::function3<ReturnValue, Param1, Param2, Param3> FunctionType;
-#else
-  typedef ReturnValue (*FunctionType)(Param1, Param2, Param3);
-#endif // BOOST_EXTENSION_USE_BOOST_FUNCTION
-  FunctionType func_;
-public:
-  bool is_valid(){return func_ != 0;}
-  functor(FunctionType func)
-    :func_(func)
-  {}
-  functor(generic_function_ptr func)
-    :func_(FunctionType((ReturnValue (*)(Param1, Param2, Param3)) func))
-  {}
-  ReturnValue operator()(Param1 p1, Param2 p2, Param3 p3)
-  {
-    return func_(p1, p2, p3);
-  }
-};
-
-template <class ReturnValue, class Param1, class Param2>
-class functor<ReturnValue, Param1, Param2>
-{
-protected:
-#ifdef BOOST_EXTENSION_USE_BOOST_FUNCTION
-  typedef boost::function2<ReturnValue, Param1, Param2> FunctionType;
-#else
-  typedef ReturnValue (*FunctionType)(Param1, Param2);
-#endif // BOOST_EXTENSION_USE_BOOST_FUNCTION
-  FunctionType func_;
-public:
-  bool is_valid(){return func_ != 0;}
-  functor(FunctionType func)
-    :func_(func)
-  {}
-  functor(generic_function_ptr func)
-    :func_(FunctionType((ReturnValue (*)(Param1, Param2)) func))
-  {}
-  ReturnValue operator()(Param1 p1, Param2 p2)
-  {
-    return func_(p1, p2);
-  }
-};
-
-template <class ReturnValue, class Param1>
-class functor<ReturnValue, Param1>
-{
-protected:
-#ifdef BOOST_EXTENSION_USE_BOOST_FUNCTION
-  typedef boost::function1<ReturnValue, Param1> FunctionType;
-#else
-  typedef ReturnValue (*FunctionType)(Param1);
-#endif // BOOST_EXTENSION_USE_BOOST_FUNCTION
-
-  FunctionType func_;
-public:
-  bool is_valid(){return func_ != 0;}
-  functor(FunctionType func)
-    :func_(func)
-  {}
-  functor(generic_function_ptr func)
-    :func_(FunctionType((ReturnValue (*)(Param1)) func))
-  {}
-  ReturnValue operator()(Param1 p1)
-  {
-    return func_(p1);
-  }
-};
-
-template <class ReturnValue>
-class functor<ReturnValue>
-{
-protected:
-#ifdef BOOST_EXTENSION_USE_BOOST_FUNCTION
-  typedef boost::function0<ReturnValue> FunctionType;
-#else
-  typedef ReturnValue (*FunctionType)();
-#endif // BOOST_EXTENSION_USE_BOOST_FUNCTION
-  FunctionType func_;
-public:
-  bool is_valid(){return func_ != 0;}
-  functor(FunctionType func)
-    :func_(func)
-  {}
-  functor(generic_function_ptr func)
-    :func_(FunctionType((ReturnValue (*)()) func))
-  {}
-  ReturnValue operator()()
-  {
-    return func_();
-  }
-};
-
-#endif // ifdef BOOST_EXTENSION_USE_PP
-
-
-class shared_library
-{
-protected:
-  std::string location_;
-  library_handle handle_;
-  bool auto_close_;
-public:
-  bool is_open(){return handle_ != 0;}
-  static bool is_linkable_library(const char * file_name) {
-    return is_library(file_name);
-  }
-  bool open(){return (handle_ = load_shared_library(location_.c_str())) != 0;}
-  bool close(){return close_shared_library(handle_);}  
-
-#ifdef BOOST_EXTENSION_USE_PP
-
-#define BOOST_EXTENSION_GET_FUNCTOR_METHOD(Z, N, _) \
-  template <class ReturnValue BOOST_PP_COMMA_IF(N) \
-            BOOST_PP_ENUM_PARAMS(N, class Param) > \
-  functor<ReturnValue BOOST_PP_COMMA_IF(N) \
-          BOOST_PP_ENUM_PARAMS(N, Param) > \
-  get_functor(const char * function_name) \
-  { \
-    return functor<ReturnValue BOOST_PP_COMMA_IF(N) \
-                   BOOST_PP_ENUM_PARAMS(N, Param)> \
-        (get_function(handle_, function_name)); \
-  } \
-  /**/
-
-  BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_EXTENSION_MAX_FUNCTOR_PARAMS), \
-                  BOOST_EXTENSION_GET_FUNCTOR_METHOD, _)
-
-#undef BOOST_EXTENSION_GET_FUNCTOR_METHOD
-#else
-  template <class ReturnValue>
-  functor<ReturnValue>
-    get_functor(const char * function_name)
-  {
-      return functor<ReturnValue>
-        (get_function(handle_, function_name));
-  }
-  template <class ReturnValue, class Param1>
-  functor<ReturnValue, Param1>
-    get_functor(const char * function_name)
-  {
-      return functor<ReturnValue, Param1>
-        (get_function(handle_, function_name));
-  }
-  template <class ReturnValue, class Param1, class Param2>
-  functor<ReturnValue, Param1, Param2>
-    get_functor(const char * function_name)
-  {
-      return functor<ReturnValue, Param1, Param2>
-        (get_function(handle_, function_name));
-  }
-  template <class ReturnValue, class Param1, class Param2, class Param3>
-  functor<ReturnValue, Param1, Param2, Param3>
-    get_functor(const char * function_name)
-  {
-      return functor<ReturnValue, Param1, Param2, Param3>
-        (get_function(handle_, function_name));
-  }
-  template <class ReturnValue, class Param1, class Param2, class Param3, 
-            class Param4>
-  functor<ReturnValue, Param1, Param2, Param3, Param4>
-    get_functor(const char * function_name)
-  {
-      return functor<ReturnValue, Param1, Param2, Param3, Param4>
-        (get_function(handle_, function_name));
-  }
-  template <class ReturnValue, class Param1, class Param2, class Param3, 
-            class Param4, class Param5>
-  functor<ReturnValue, Param1, Param2, Param3, Param4, Param5>
-    get_functor(const char * function_name)
-  {
-      return functor<ReturnValue, Param1, Param2, Param3, Param4, Param5>
-        (get_function(handle_, function_name));
-  }
-  template <class ReturnValue, class Param1, class Param2, class Param3, 
-            class Param4, class Param5, class Param6>
-  functor<ReturnValue, Param1, Param2, Param3, Param4, Param5, Param6>
-    get_functor(const char * function_name)
-  {
-      return functor<ReturnValue, Param1, Param2, Param3, Param4, Param5, 
-      Param6>
-        (get_function(handle_, function_name));
-  }
-#endif // BOOST_EXTENSION_USE_PP
-
-shared_library(const char * location, bool auto_close = false)
-    :location_(location), handle_(0), auto_close_(auto_close){}
-};
-}}
-
-
-#endif

Modified: sandbox/libs/extension/test/Jamfile.v2
==============================================================================
--- sandbox/libs/extension/test/Jamfile.v2	(original)
+++ sandbox/libs/extension/test/Jamfile.v2	2007-09-04 23:56:48 EDT (Tue, 04 Sep 2007)
@@ -14,7 +14,6 @@
 project
     : requirements
       <library>$(BOOST_ROOT)libs/test/build//boost_unit_test_framework/<link>shared
-      # <source>auto_test_main.cpp
       <include>../../../
       <include>$(BOOST_ROOT)
       <define>BOOST_TEST_NO_AUTO_LINK=1
@@ -28,16 +27,20 @@
 
 
 test-suite extension_tests_all
-: [ run factory_test.cpp ] 
-  [ run zone_test.cpp ] 
+:
+ # [ run factory_test.cpp ] 
+ # [ run zone_test.cpp ] 
   [ run construction.cpp ]
-  [ run hello_world_test.cpp ]
+  [ run single_param_test.cpp ]
+  [ run double_param_test.cpp ]
+  [ run mixed_param_test.cpp ]
+ # [ run hello_world_test.cpp ]
  # [ run lib_caching_test.cpp ]
-  [ run versions_test.cpp ]
-  [ run parameters_test.cpp ]
-  [ run multiple_inheritance_test.cpp ]
-  [ run extension_test.cpp ]
-  [ run counted_factory_test.cpp ]
+ # [ run versions_test.cpp ]
+ # [ run parameters_test.cpp ]
+ # [ run multiple_inheritance_test.cpp ]
+ # [ run extension_test.cpp ]
+ # [ run counted_factory_test.cpp ]
  # [ run registry_test.cpp ]
 : 
 ;

Modified: sandbox/libs/extension/test/construction.cpp
==============================================================================
--- sandbox/libs/extension/test/construction.cpp	(original)
+++ sandbox/libs/extension/test/construction.cpp	2007-09-04 23:56:48 EDT (Tue, 04 Sep 2007)
@@ -9,28 +9,130 @@
  * See http://www.boost.org/ for latest version.
  */
 
-#include <boost/extension/factory_map.hpp>
+
 #include <boost/extension/factory.hpp>
-#include <boost/extension/shared_library.hpp>
+#include <boost/extension/factory_map.hpp>
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
+#include <memory>
+#include <map>
 
+using namespace boost::extensions;
 
 
-using namespace boost::extensions;
+class Automobile {
+public:
+  virtual ~Automobile() {}
+  Automobile() {}
+  virtual int getSpeed() {return 45;}
+};
+
+class Van : virtual public Automobile {
+public:
+  virtual ~Van() {}
+  Van() {}
+  virtual int getSpeed() {return 35;}
+};
+
+class PickupTruck : virtual public Automobile {
+public:
+  virtual ~PickupTruck() {}
+  PickupTruck() {}
+  virtual int getSpeed() {return 50;}
+};
+
+class Racecar : virtual public Automobile {
+public:
+  virtual ~Racecar() {}
+  Racecar(int speed) : speed_(speed) {}
+  virtual int getSpeed() {return speed_;}
+private:
+  int speed_;
+};
 
-BOOST_AUTO_TEST_CASE(zone_construction)
+class RacingVan : public Racecar, public Van
 {
-  factory_map z;
+public:
+  virtual ~RacingVan() {}
+  RacingVan() : Racecar(120) {}
+  virtual int getSpeed() {return Racecar::getSpeed();}
+};
 
+
+
+
+BOOST_AUTO_TEST_CASE(factory_argless) {
+  factory<Automobile> f;
+  f.set<PickupTruck>();
+  BOOST_CHECK(f.is_valid());
+  std::auto_ptr<Automobile> pickup(f.create());
+  BOOST_CHECK_EQUAL(pickup->getSpeed(), 50);
 }
-BOOST_AUTO_TEST_CASE(factory_construction)
+
+BOOST_AUTO_TEST_CASE(map_argless)
 {
-  //factory f;
+  std::map<std::string, factory<Automobile> > m;
+  m["A van"].set<Van>();
+  m["A basic automobile"].set<Automobile>();
+  m["A pickup truck"].set<PickupTruck>();
+  std::auto_ptr<Automobile> van(m["A van"].create());
+  BOOST_CHECK_EQUAL(van->getSpeed(), 35);
+  BOOST_CHECK_EQUAL
+    (m["An unloaded car!"].create(),
+     (Automobile*)0);
+}
 
+template <>
+Automobile * create_function<Automobile, Racecar>::create()
+{
+  return new Racecar(101);
 }
-BOOST_AUTO_TEST_CASE(linked_library_construction)
+
+BOOST_AUTO_TEST_CASE(factory_template)
 {
-  shared_library l((std::string("liblocal") + ".extension").c_str());
+  factory<Automobile> f;
+  f.set<Racecar>();
+  BOOST_CHECK(f.is_valid());
+  std::auto_ptr<Automobile> racecar(f.create());
+  BOOST_CHECK_EQUAL(racecar->getSpeed(), 101);
+}
 
+BOOST_AUTO_TEST_CASE(factory_map_argless)
+{
+  factory_map m;
+  m.get<Automobile, std::string>()["A pickup truck"].set<PickupTruck>();
+  m.get<Automobile, std::string>()["A racing van!"].set<RacingVan>();
+  std::auto_ptr<Automobile> pickup
+    (m.get<Automobile, std::string>()["A pickup truck"].create());
+  BOOST_CHECK_EQUAL(pickup->getSpeed(), 50);
+  std::auto_ptr<Automobile> racingVan
+    (m.get<Automobile, std::string>()["A racing van!"].create());
+  BOOST_CHECK_EQUAL(racingVan->getSpeed(), 120);
+  std::auto_ptr<Automobile> car_ptr
+    (m.get<Automobile, std::string>()["A nonexistent car!"].create());
+  BOOST_CHECK_EQUAL(car_ptr.get(), (Automobile*)0);
 }
+/*
+BOOST_AUTO_TEST_CASE(registry_argless2)
+{
+  registry r;
+  r.add<PickupTruck, Automobile, std::string>("A pickup truck");
+  r.add<RacingVan, Automobile, std::string>("A racing van!");
+  factory_map<Automobile, std::string> & m1(r.get<Automobile, std::string>());
+  factory_map<Automobile, std::string> & m2(r.get());
+  BOOST_CHECK_EQUAL(m1.size(), 2);
+}
+
+BOOST_AUTO_TEST_CASE(counted_registry_argless)
+{
+  count_registry r;
+  r.add<PickupTruck, Automobile, std::string>("A pickup truck");
+  r.add<RacingVan, Automobile, std::string>("A racing van!");
+  {
+    BOOST_CHECK_EQUAL(r.instances(), 0);
+    std::auto_ptr<Automobile> pickup =
+      r.create<Automobile, std::string>("A pickup truck");
+    BOOST_CHECK_EQUAL(r.instances(), 1);
+  }
+  BOOST_CHECK_EQUAL(r.instances(), 0);
+}*/