From: mconsoni_at_[hidden]
Date: 2007-06-26 16:18:37
Author: mconsoni
Date: 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
New Revision: 7177
URL: http://svn.boost.org/trac/boost/changeset/7177
Log:
- make it fit in 80 columns... sounds easy, but it was a loooooong task.
Text files modified:
sandbox/boost/extension/convenience.hpp | 8 +
sandbox/boost/extension/counted_factory.hpp | 135 ++++++++++++++++------
sandbox/boost/extension/counted_factory_map.hpp | 235 +++++++++++++++++++++++++--------------
sandbox/boost/extension/factory.hpp | 97 +++++++++++----
sandbox/boost/extension/factory_map.hpp | 176 +++++++++++++++++++----------
sandbox/boost/extension/filesystem.hpp | 11 +
sandbox/boost/extension/functor.hpp | 23 ++-
sandbox/boost/extension/impl/library_impl.hpp | 46 +++++--
sandbox/boost/extension/registry.hpp | 11 +
sandbox/boost/extension/shared_library.hpp | 36 ++++-
10 files changed, 519 insertions(+), 259 deletions(-)
Modified: sandbox/boost/extension/convenience.hpp
==============================================================================
--- sandbox/boost/extension/convenience.hpp (original)
+++ sandbox/boost/extension/convenience.hpp 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
@@ -17,14 +17,18 @@
namespace boost{namespace extensions{
-inline void load_single_library(factory_map & current_zone, const char * library_path, const char * external_function_name)
+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);
+ functor<void, factory_map &> load_func =
+ lib.get_functor<void, factory_map &>(external_function_name);
+
if (!load_func.is_valid())
{
return;
Modified: sandbox/boost/extension/counted_factory.hpp
==============================================================================
--- sandbox/boost/extension/counted_factory.hpp (original)
+++ sandbox/boost/extension/counted_factory.hpp 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,7 @@
/*
* Boost.Extension / counted factory:
- * factory to register the implementations and create them (with a reference count)
+ * 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
@@ -14,7 +15,9 @@
#define BOOST_EXTENSION_COUNTED_FACTORY_HPP
#include <string>
namespace boost{namespace extensions{
- template <class Interface, class Info, class Param1 = void, class Param2 = void, class Param3 = void, class Param4 = void, class Param5 = void, class Param6 = void>
+ 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:
@@ -24,7 +27,8 @@
{
public:
virtual ~generic_factory_function(){}
- virtual Interface * operator()(int * counter, Param1, Param2, Param3, Param4, Param5, Param6) = 0;
+ virtual Interface * operator()(int * counter, Param1, Param2, Param3,
+ Param4, Param5, Param6) = 0;
virtual generic_factory_function * copy() const = 0;
};
template <class T>
@@ -36,7 +40,9 @@
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),
+ 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_);
@@ -48,12 +54,17 @@
};
virtual ~factory_function(){}
virtual Interface * operator()
- (int * counter, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)
+ (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>;}
+ 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_;
@@ -71,9 +82,11 @@
return library_.c_str();
}
template <class Actual>
- void set_type_special(Actual *){factory_func_ptr_.reset(new factory_function<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>();}
+ void set_type(){factory_func_ptr_ = new factory_function<Actual>();}
counted_factory(Info info)
:factory_func_ptr_(0),
info_(info)
@@ -84,13 +97,16 @@
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)
+ 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_)
+ 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>
+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:
@@ -100,7 +116,8 @@
{
public:
virtual ~generic_factory_function(){}
- virtual Interface * operator()(int * counter, Param1, Param2, Param3, Param4, Param5) = 0;
+ virtual Interface * operator()(int * counter, Param1, Param2, Param3,
+ Param4, Param5) = 0;
virtual generic_factory_function * copy() const = 0;
};
template <class T>
@@ -112,7 +129,8 @@
private:
int * counter_;
public:
- counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) : T(p1, p2, p3, p4, p5),
+ counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3,
+ Param4 p4, Param5 p5) : T(p1, p2, p3, p4, p5),
counter_(counter)
{
++(*counter_);
@@ -128,8 +146,11 @@
{ // 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>;}
+ 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_;
@@ -147,7 +168,8 @@
return library_.c_str();
}
template <class Actual>
- void set_type_special(Actual *){factory_func_ptr_.reset(new factory_function<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)
@@ -160,13 +182,16 @@
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)
+ 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);}
+ 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>
+template <class Interface, class Info, class Param1, class Param2,
+ class Param3, class Param4>
class counted_factory<Interface, Info, Param1, Param2, Param3, Param4>
{
protected:
@@ -176,7 +201,8 @@
{
public:
virtual ~generic_factory_function(){}
- virtual Interface * operator()(int * counter, Param1, Param2, Param3, Param4) = 0;
+ virtual Interface * operator()(int * counter, Param1, Param2, Param3,
+ Param4) = 0;
virtual generic_factory_function * copy() const = 0;
};
template <class T>
@@ -188,7 +214,8 @@
private:
int * counter_;
public:
- counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3, Param4 p4) : T(p1, p2, p3, p4),
+ counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3,
+ Param4 p4) : T(p1, p2, p3, p4),
counter_(counter)
{
++(*counter_);
@@ -204,8 +231,11 @@
{ // 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>;}
+ 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_;
@@ -223,7 +253,9 @@
return library_.c_str();
}
template <class Actual>
- void set_type_special(Actual *){factory_func_ptr_.reset(new factory_function<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)
@@ -236,13 +268,16 @@
factory_func_ptr_(first.factory_func_ptr_->copy()),
info_(first.info_)
{}
- Interface * operator()(int * counter, Param1 p1, Param2 p2, Param3 p3, Param4 p4)
+ 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);}
+ 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>
+template <class Interface, class Info, class Param1, class Param2,
+ class Param3>
class counted_factory<Interface, Info, Param1, Param2, Param3>
{
protected:
@@ -264,7 +299,8 @@
private:
int * counter_;
public:
- counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3) : T(p1, p2, p3),
+ counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3)
+ : T(p1, p2, p3),
counter_(counter)
{
++(*counter_);
@@ -281,7 +317,9 @@
// 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>;}
+ virtual generic_factory_function * copy() const {
+ return new factory_function<T>;
+ }
};
std::auto_ptr<generic_factory_function> factory_func_ptr_;
Info info_;
@@ -299,7 +337,9 @@
return library_.c_str();
}
template <class Actual>
- void set_type_special(Actual *){factory_func_ptr_.reset(new factory_function<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)
@@ -314,8 +354,9 @@
{}
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);}
+ 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>
@@ -357,7 +398,9 @@
// 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>;}
+ virtual generic_factory_function * copy() const {
+ return new factory_function<T>;
+ }
};
std::auto_ptr<generic_factory_function> factory_func_ptr_;
Info info_;
@@ -375,7 +418,9 @@
return library_.c_str();
}
template <class Actual>
- void set_type_special(Actual *){factory_func_ptr_.reset(new factory_function<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)
@@ -433,7 +478,9 @@
// 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>;}
+ virtual generic_factory_function * copy() const {
+ return new factory_function<T>;
+ }
};
std::auto_ptr<generic_factory_function> factory_func_ptr_;
Info info_;
@@ -451,7 +498,9 @@
return library_.c_str();
}
template <class Actual>
- void set_type_special(Actual *){factory_func_ptr_.reset(new factory_function<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)
@@ -509,7 +558,9 @@
// 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>;}
+ virtual generic_factory_function * copy() const {
+ return new factory_function<T>;
+ }
};
std::auto_ptr<generic_factory_function> factory_func_ptr_;
Info info_;
@@ -527,7 +578,9 @@
return library_.c_str();
}
template <class Actual>
- void set_type_special(Actual *){factory_func_ptr_.reset(new factory_function<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)
Modified: sandbox/boost/extension/counted_factory_map.hpp
==============================================================================
--- sandbox/boost/extension/counted_factory_map.hpp (original)
+++ sandbox/boost/extension/counted_factory_map.hpp 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
@@ -32,8 +32,13 @@
virtual bool remove_library(const char * library_name) = 0;
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<counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5, Param6> >, public 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<counted_factory<Interface, Info, Param1, Param2, Param3,
+ Param4, Param5, Param6> >,
+ public generic_factory_container
{
public:
int * counter_;
@@ -41,9 +46,10 @@
virtual ~factory_container() {--(*counter_);}
virtual bool remove_library(const char * library_name)
{
- for (typename std::list<counted_factory<Interface, Info, Param1, Param2, Param3,
- Param4, Param5, Param6> >::iterator it = this->begin();
- it != this->end();)
+ for (typename std::list<counted_factory<Interface, Info, Param1,
+ Param2, Param3, Param4, Param5, Param6> >::iterator it =
+ this->begin();
+ it != this->end();)
{
if (strcmp(it->library(), library_name) == 0)
this->erase(it++);
@@ -54,7 +60,9 @@
}
// factory_container() {}
// factory_container(basic_counted_factory_map & z)
- // :std::list<counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5, Param6> >(z.get<Interface, Param1, Param2, Param3, Param4, Param5, Param6>()){}
+ // :std::list<counted_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;
@@ -63,9 +71,11 @@
int default_counter_;
int * current_counter_;
public:
- basic_counted_factory_map() : default_counter_(0), current_counter_(&default_counter_){}
+ basic_counted_factory_map() : default_counter_(0),
+ current_counter_(&default_counter_){}
~basic_counted_factory_map(){
- for(typename FactoryMap::iterator it = factories_.begin(); it != factories_.end(); ++it)
+ for(typename FactoryMap::iterator it = factories_.begin();
+ it != factories_.end(); ++it)
delete it->second;
//TODO - test for memory leaks.
}
@@ -76,7 +86,8 @@
std::list<counted_factory<Interface, Info> > & get()
{
TypeInfo current_type =
- type_info_handler<TypeInfo, counted_factory<Interface, Info> >::get_class_type();
+ type_info_handler<TypeInfo,
+ counted_factory<Interface, Info> >::get_class_type();
typename FactoryMap::iterator it =
factories_.find(current_type);
@@ -90,7 +101,8 @@
else
{
// Change to dynamic if this fails
- return static_cast<factory_container<Interface, Info> &>(*(it->second));
+ return static_cast<factory_container<Interface,
+ Info> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info>
@@ -113,9 +125,9 @@
std::list<counted_factory<Interface, Info, Param1> > & get()
{
TypeInfo current_type =
- type_info_handler<TypeInfo, counted_factory<Interface, Info, Param1> >::get_class_type();
- typename FactoryMap::iterator it =
- factories_.find(current_type);
+ type_info_handler<TypeInfo, counted_factory<Interface, Info,
+ Param1> >::get_class_type();
+ typename FactoryMap::iterator it = factories_.find(current_type);
if (it == factories_.end())
{
@@ -127,7 +139,8 @@
else
{
// Change to dynamic if this fails
- return static_cast<factory_container<Interface, Info, Param1> &>(*(it->second));
+ return static_cast<factory_container<Interface, Info,
+ Param1> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1>
@@ -150,27 +163,32 @@
std::list<counted_factory<Interface, Info, Param1, Param2> > & get()
{
TypeInfo current_type =
- type_info_handler<TypeInfo, counted_factory<Interface, Info, Param1, Param2> >::get_class_type();
+ type_info_handler<TypeInfo, counted_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>(current_counter_);
+ new factory_container<Interface, Info, Param1,
+ Param2>(current_counter_);
factories_[current_type] = ret;
return *ret;
}
else
{
// Change to dynamic if this fails
- return static_cast<factory_container<Interface, Info, Param1, Param2> &>(*(it->second));
+ return static_cast<factory_container<Interface, Info, Param1,
+ Param2> &>(*(it->second));
}
}
-template <class Actual, class Interface, class Info, class Param1, class Param2>
+template <class Actual, class Interface, class Info, class Param1,
+ class Param2>
void add(Info info)
{
- typedef std::list<counted_factory<Interface, Info, Param1, Param2> > ListType;
+ typedef std::list<counted_factory<Interface, Info, Param1, Param2> >
+ ListType;
ListType & s = this->get<Interface, Info, Param1, Param2>();
counted_factory<Interface, Info, Param1, Param2> f(info);
f.set_library(current_library_.c_str());
@@ -180,34 +198,42 @@
s.push_back(f);
//it->set_type<Actual>();
}
- template <class Interface, class Info, class Param1, class Param2, class Param3>
-operator std::list<counted_factory<Interface, Info, Param1, Param2, Param3> > & ()
+ template <class Interface, class Info, class Param1, class Param2,
+ class Param3>
+operator std::list<counted_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>
+ template <class Interface, class Info, class Param1, class Param2,
+ class Param3>
std::list<counted_factory<Interface, Info, Param1, Param2, Param3> > & get()
{
TypeInfo current_type =
- type_info_handler<TypeInfo, counted_factory<Interface, Info, Param1, Param2, Param3> >::get_class_type();
+ type_info_handler<TypeInfo, counted_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>(current_counter_);
+ new factory_container<Interface, Info, Param1, Param2,
+ Param3>(current_counter_);
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));
+ 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>
+template <class Actual, class Interface, class Info, class Param1,
+ class Param2, class Param3>
void add(Info info)
{
- typedef std::list<counted_factory<Interface, Info, Param1, Param2, Param3> > ListType;
+ typedef std::list<counted_factory<Interface, Info, Param1, Param2,
+ Param3> > ListType;
ListType & s = this->get<Interface, Info, Param1, Param2, Param3>();
counted_factory<Interface, Info, Param1, Param2, Param3> f(info);
f.set_library(current_library_.c_str());
@@ -217,35 +243,46 @@
s.push_back(f);
//it->set_type<Actual>();
}
- template <class Interface, class Info, class Param1, class Param2, class Param3, class Param4>
-operator std::list<counted_factory<Interface, Info, Param1, Param2, Param3, Param4> > & ()
+ template <class Interface, class Info, class Param1, class Param2,
+ class Param3, class Param4>
+operator std::list<counted_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<counted_factory<Interface, Info, Param1, Param2, Param3, Param4> > & get()
+ template <class Interface, class Info, class Param1, class Param2,
+ class Param3, class Param4>
+std::list<counted_factory<Interface, Info, Param1, Param2, Param3,
+ Param4> > & get()
{
TypeInfo current_type =
- type_info_handler<TypeInfo, counted_factory<Interface, Info, Param1, Param2, Param3, Param4> >::get_class_type();
+ type_info_handler<TypeInfo, counted_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>(current_counter_);
+ factory_container<Interface, Info, Param1, Param2, Param3,
+ Param4> * ret =
+ new factory_container<Interface, Info, Param1, Param2, Param3,
+ Param4>(current_counter_);
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));
+ 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>
+template <class Actual, class Interface, class Info, class Param1,
+ class Param2, class Param3, class Param4>
void add(Info info)
{
- typedef std::list<counted_factory<Interface, Info, Param1, Param2, Param3, Param4> > ListType;
- ListType & s = this->get<Interface, Info, Param1, Param2, Param3, Param4>();
+ typedef std::list<counted_factory<Interface, Info, Param1, Param2,
+ Param3, Param4> > ListType;
+ ListType & s = this->get<Interface, Info, Param1, Param2, Param3,
+ Param4>();
counted_factory<Interface, Info, Param1, Param2, Param3, Param4> f(info);
f.set_library(current_library_.c_str());
f.set_counter(current_counter_);
@@ -254,36 +291,47 @@
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<counted_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<counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5> > & get()
- {
- TypeInfo current_type =
- type_info_handler<TypeInfo, counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5> >::get_class_type();
- typename FactoryMap::iterator it =
- factories_.find(current_type);
+ template <class Interface, class Info, class Param1, class Param2,
+ class Param3, class Param4, class Param5>
+ operator std::list<counted_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<counted_factory<Interface, Info, Param1, Param2, Param3, Param4,
+ Param5> > & get()
+ {
+ TypeInfo current_type =
+ type_info_handler<TypeInfo, counted_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>(current_counter_);
- 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));
- }
+ if (it == factories_.end()) {
+ factory_container<Interface, Info, Param1, Param2, Param3, Param4,
+ Param5> * ret = new factory_container<Interface, Info, Param1, Param2,
+ Param3, Param4, Param5>(current_counter_);
+ 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<counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5> > ListType;
- ListType & s = this->get<Interface, Info, Param1, Param2, Param3, Param4, Param5>();
- counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5> f(info);
+ template <class Actual, class Interface, class Info, class Param1,
+ class Param2, class Param3, class Param4, class Param5>
+ void add(Info info)
+ {
+ typedef std::list<counted_factory<Interface, Info, Param1, Param2,
+ Param3, Param4, Param5> > ListType;
+ ListType & s = this->get<Interface, Info, Param1, Param2, Param3, Param4,
+ Param5>();
+ counted_factory<Interface, Info, Param1, Param2, Param3, Param4,
+ Param5> f(info);
f.set_library(current_library_.c_str());
f.set_counter(current_counter_);
//f.set_type<Actual>();
@@ -291,36 +339,49 @@
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<counted_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<counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5, Param6> > & get()
- {
- TypeInfo current_type =
- type_info_handler<TypeInfo, counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5, Param6> >::get_class_type();
- typename FactoryMap::iterator it =
- factories_.find(current_type);
+ template <class Interface, class Info, class Param1, class Param2,
+ class Param3, class Param4, class Param5, class Param6>
+ operator std::list<counted_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<counted_factory<Interface, Info, Param1, Param2, Param3, Param4,
+ Param5, Param6> > & get()
+ {
+ TypeInfo current_type =
+ type_info_handler<TypeInfo, counted_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>(current_counter_);
+ 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>(current_counter_);
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));
+ 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<counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5, Param6> > ListType;
- ListType & s = this->get<Interface, Info, Param1, Param2, Param3, Param4, Param5, Param6>();
- counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5, Param6> f(info);
+ 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<counted_factory<Interface, Info, Param1, Param2,
+ Param3, Param4, Param5, Param6> > ListType;
+ ListType & s = this->get<Interface, Info, Param1, Param2, Param3,
+ Param4, Param5, Param6>();
+ counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5,
+ Param6> f(info);
f.set_library(current_library_.c_str());
f.set_counter(current_counter_);
//f.set_type<Actual>();
Modified: sandbox/boost/extension/factory.hpp
==============================================================================
--- sandbox/boost/extension/factory.hpp (original)
+++ sandbox/boost/extension/factory.hpp 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
@@ -14,7 +14,9 @@
#define BOOST_EXTENSION_FACTORY_HPP
#include <string>
namespace boost{namespace extensions{
- template <class Interface, class Info, class Param1 = void, class Param2 = void, class Param3 = void, class Param4 = void, class Param5 = void, class Param6 = void>
+ 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:
@@ -22,7 +24,8 @@
{
public:
virtual ~generic_factory_function(){}
- virtual Interface * operator()(Param1, Param2, Param3, Param4, Param5, Param6) = 0;
+ virtual Interface * operator()(Param1, Param2, Param3, Param4, Param5,
+ Param6) = 0;
virtual generic_factory_function * copy() const = 0;
};
template <class T>
@@ -33,13 +36,17 @@
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>;}
+ 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>());}
+ 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)
@@ -50,13 +57,18 @@
: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)
+ 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);}
+ 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>
+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:
@@ -75,13 +87,17 @@
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>;}
+ 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>());}
+ 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)
@@ -94,11 +110,13 @@
{}
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);}
+ 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>
+template <class Interface, class Info, class Param1, class Param2,
+ class Param3, class Param4>
class factory<Interface, Info, Param1, Param2, Param3, Param4>
{
protected:
@@ -117,13 +135,17 @@
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>;}
+ 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>());}
+ 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)
@@ -136,11 +158,13 @@
{}
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);}
+ 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>
+template <class Interface, class Info, class Param1, class Param2,
+ class Param3>
class factory<Interface, Info, Param1, Param2, Param3>
{
protected:
@@ -159,13 +183,17 @@
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>;}
+ 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>());}
+ 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)
@@ -178,8 +206,9 @@
{}
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);}
+ 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>
@@ -201,13 +230,17 @@
virtual Interface * operator()
(Param1 p1, Param2 p2)
{return new T(p1, p2);}
- virtual generic_factory_function * copy() const {return new factory_function<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>());}
+ 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)
@@ -243,13 +276,17 @@
virtual Interface * operator()
(Param1 p1)
{return new T(p1);}
- virtual generic_factory_function * copy() const {return new factory_function<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>());}
+ 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)
@@ -285,13 +322,17 @@
virtual Interface * operator()
()
{return new T();}
- virtual generic_factory_function * copy() const {return new factory_function<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>());}
+ 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)
Modified: sandbox/boost/extension/factory_map.hpp
==============================================================================
--- sandbox/boost/extension/factory_map.hpp (original)
+++ sandbox/boost/extension/factory_map.hpp 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
@@ -31,25 +31,35 @@
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
+ 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>()){}
+ // :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>()){}
+ // :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)
+ for(typename FactoryMap::iterator it = factories_.begin();
+ it != factories_.end(); ++it)
delete it->second;
//TODO - test for memory leaks.
}
@@ -60,9 +70,9 @@
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);
+ type_info_handler<TypeInfo,
+ factory<Interface, Info> >::get_class_type();
+ typename FactoryMap::iterator it = factories_.find(current_type);
if (it == factories_.end())
{
@@ -74,7 +84,8 @@
else
{
// Change to dynamic if this fails
- return static_cast<factory_container<Interface, Info> &>(*(it->second));
+ return static_cast<factory_container<Interface,
+ Info> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info>
@@ -94,8 +105,8 @@
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();
+ TypeInfo current_type = type_info_handler<TypeInfo,
+ factory<Interface, Info, Param1> >::get_class_type();
typename FactoryMap::iterator it =
factories_.find(current_type);
@@ -109,7 +120,8 @@
else
{
// Change to dynamic if this fails
- return static_cast<factory_container<Interface, Info, Param1> &>(*(it->second));
+ return static_cast<factory_container<Interface,
+ Info, Param1> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1>
@@ -130,7 +142,8 @@
std::list<factory<Interface, Info, Param1, Param2> > & get()
{
TypeInfo current_type =
- type_info_handler<TypeInfo, factory<Interface, Info, Param1, Param2> >::get_class_type();
+ type_info_handler<TypeInfo, factory<Interface, Info, Param1,
+ Param2> >::get_class_type();
typename FactoryMap::iterator it =
factories_.find(current_type);
@@ -144,10 +157,12 @@
else
{
// Change to dynamic if this fails
- return static_cast<factory_container<Interface, Info, Param1, Param2> &>(*(it->second));
+ return static_cast<factory_container<Interface, Info, Param1,
+ Param2> &>(*(it->second));
}
}
-template <class Actual, class Interface, class Info, class Param1, class Param2>
+template <class Actual, class Interface, class Info, class Param1,
+ class Param2>
void add(Info info)
{
typedef std::list<factory<Interface, Info, Param1, Param2> > ListType;
@@ -158,16 +173,18 @@
s.push_back(f);
//it->set_type<Actual>();
}
- template <class Interface, class Info, class Param1, class Param2, class Param3>
+ 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>
+ 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);
+ 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())
{
@@ -179,13 +196,16 @@
else
{
// Change to dynamic if this fails
- return static_cast<factory_container<Interface, Info, Param1, Param2, Param3> &>(*(it->second));
+ 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>
+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;
+ 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>();
@@ -193,106 +213,138 @@
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> > & ()
+ 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>
+ 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);
+ 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>();
+ 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));
+ 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>
+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>();
+ 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()
+ 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();
+ 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>();
+ 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));
+ 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>
+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>();
+ 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();
+ 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>();
+ 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));
+ 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>
+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);
+ 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);
Modified: sandbox/boost/extension/filesystem.hpp
==============================================================================
--- sandbox/boost/extension/filesystem.hpp (original)
+++ sandbox/boost/extension/filesystem.hpp 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
@@ -21,7 +21,10 @@
namespace boost{namespace extensions{
-inline void load_all_libraries(factory_map & current_zone, const char * directory, const char * external_function_name, int max_depth = 0)
+inline void load_all_libraries(factory_map & current_zone,
+ const char * directory,
+ const char * external_function_name,
+ int max_depth = 0)
{
if (max_depth < 0) return; // Recursion base case
filesystem::directory_iterator end_file_iter;
@@ -31,11 +34,13 @@
{
if (is_directory(*file_iter))
{
- load_all_libraries(current_zone, directory, file_iter->string().c_str(), max_depth - 1);
+ load_all_libraries(current_zone, directory, file_iter->string().c_str(),
+ max_depth - 1);
}
else if (is_library(filesystem::extension(*file_iter).c_str()))
{
- load_single_library(current_zone, file_iter->string().c_str(), external_function_name);
+ load_single_library(current_zone, file_iter->string().c_str(),
+ external_function_name);
}
}
}
Modified: sandbox/boost/extension/functor.hpp
==============================================================================
--- sandbox/boost/extension/functor.hpp (original)
+++ sandbox/boost/extension/functor.hpp 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
@@ -65,11 +65,13 @@
#undef BOOST_EXTENSIONS_FUNCTOR_CLASS
#else
-template <class ReturnValue, class Param1 = void, class Param2 = void, class Param3 = void,
-class Param4 = void, class Param5 = void, class Param6 = void>
+template <class ReturnValue, class Param1 = void, class Param2 = void,
+ class Param3 = void, class Param4 = void, class Param5 = void,
+ class Param6 = void>
class functor {
private:
- typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4, Param5, Param6);
+ typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4,
+ Param5, Param6);
FunctionType func_;
public:
@@ -83,17 +85,20 @@
: func_(FunctionType(func))
{}
- ReturnValue operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)
+ 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>
+template <class ReturnValue, class Param1, class Param2, class Param3,
+ class Param4, class Param5>
class functor<ReturnValue, Param1, Param2, Param3, Param4, Param5>
{
private:
- typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4, Param5);
+ typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4,
+ Param5);
FunctionType func_;
public:
@@ -105,13 +110,15 @@
functor(generic_function_ptr func)
:func_(FunctionType(func))
{}
- ReturnValue operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)
+ 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>
+template <class ReturnValue, class Param1, class Param2, class Param3,
+ class Param4>
class functor<ReturnValue, Param1, Param2, Param3, Param4>
{
private:
Modified: sandbox/boost/extension/impl/library_impl.hpp
==============================================================================
--- sandbox/boost/extension/impl/library_impl.hpp (original)
+++ sandbox/boost/extension/impl/library_impl.hpp 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
@@ -30,11 +30,19 @@
inline bool is_library(const char * file_name)
{
int len = strlen(file_name);
- return (len > 3 && file_name[len-4] == '.' && file_name[len-3] == 'd' && file_name[len-2] == 'l' && file_name[len-1] == 'l');
+ return (len > 3 && file_name[len-4] == '.' && file_name[len-3] == 'd'
+ && file_name[len-2] == 'l' && file_name[len-1] == 'l');
+ }
+ inline library_handle load_shared_library(const char * libraryName) {
+ return LoadLibrary(libraryName);
+ }
+ inline generic_function_ptr get_function(library_handle handle,
+ const char * function_name) {
+ return GetProcAddress(handle, function_name);
+ }
+ inline bool close_shared_library(library_handle handle) {
+ return FreeLibrary(handle)!=0;
}
- inline library_handle load_shared_library(const char * libraryName){return LoadLibrary(libraryName);}
- inline generic_function_ptr get_function(library_handle handle, const char * function_name){return GetProcAddress(handle, function_name);}
- inline bool close_shared_library(library_handle handle){return FreeLibrary(handle)!=0;}
}
# pragma comment(lib, "kernel32.lib")
#else
@@ -44,11 +52,15 @@
inline bool is_library(const char * file_name)
{
int len = strlen(file_name);
- return ((len > 5 && file_name[len-7] == '.' && file_name[len-6] == 'b' && file_name[len-5] == 'u' &&
- file_name[len-4] == 'n' && file_name[len-3] == 'd' && file_name[len-2] == 'l' &&
- file_name[len-1] == 'e') || (len > 4 && file_name[len-6] == '.' &&
- file_name[len-5] == 'd' && file_name[len-4] == 'y' && file_name[len-3] == 'l' &&
- file_name[len-2] == 'i' && file_name[len-1] == 'b'));
+ return ((len > 5 && file_name[len-7] == '.' && file_name[len-6] == 'b'
+ && file_name[len-5] == 'u' && file_name[len-4] == 'n'
+ && file_name[len-3] == 'd' && file_name[len-2] == 'l' &&
+ file_name[len-1] == 'e') || (len > 4 && file_name[len-6] == '.'
+ && file_name[len-5] == 'd'
+ && file_name[len-4] == 'y'
+ && file_name[len-3] == 'l' &&
+ file_name[len-2] == 'i'
+ && file_name[len-1] == 'b'));
}
}
#define BOOST_EXTENSION_LIBRARY_EXTENSION "dylib"
@@ -59,7 +71,8 @@
inline bool is_library(const char * file_name)
{
int len = strlen(file_name);
- return (len > 2 && file_name[len-3] == '.' && file_name[len-2] == 's' && file_name[len-1] == 'o');
+ return (len > 2 && file_name[len-3] == '.' && file_name[len-2] == 's'
+ && file_name[len-1] == 'o');
}
}
#define BOOST_EXTENSION_LIBRARY_EXTENSION "so"
@@ -70,9 +83,16 @@
{
typedef void * library_handle;
typedef void * generic_function_ptr;
- inline library_handle load_shared_library(const char * library_name){return dlopen(library_name, RTLD_LAZY);}
- inline generic_function_ptr get_function(library_handle handle, const char * function_name){return dlsym(handle, function_name);}
- inline bool close_shared_library(library_handle handle){return dlclose(handle)==0;}
+ inline library_handle load_shared_library(const char * library_name) {
+ return dlopen(library_name, RTLD_LAZY);
+ }
+ inline generic_function_ptr get_function(library_handle handle,
+ const char * function_name) {
+ return dlsym(handle, function_name);
+ }
+ inline bool close_shared_library(library_handle handle) {
+ return dlclose(handle)==0;
+ }
}
#endif
Modified: sandbox/boost/extension/registry.hpp
==============================================================================
--- sandbox/boost/extension/registry.hpp (original)
+++ sandbox/boost/extension/registry.hpp 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
@@ -52,7 +52,9 @@
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;
+ 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();
@@ -61,7 +63,8 @@
return false;
}
functor<void, counted_factory_map &> load_func =
- it->second.first.get_functor<void, counted_factory_map &>(function_name);
+ it->second.first.get_functor<void, counted_factory_map &>
+ (function_name);
if (load_func.is_valid())
{
load_func(*this);
@@ -76,8 +79,8 @@
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();) {
+ 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;
Modified: sandbox/boost/extension/shared_library.hpp
==============================================================================
--- sandbox/boost/extension/shared_library.hpp (original)
+++ sandbox/boost/extension/shared_library.hpp 2007-06-26 16:18:35 EDT (Tue, 26 Jun 2007)
@@ -16,11 +16,14 @@
namespace boost{namespace extensions{
-template <class ReturnValue, class Param1 = void, class Param2 = void, class Param3 = void, class Param4 = void, class Param5 = void, class Param6 = void>
+template <class ReturnValue, class Param1 = void, class Param2 = void,
+ class Param3 = void, class Param4 = void, class Param5 = void,
+ class Param6 = void>
class functor
{
protected:
- typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4, Param5, Param6);
+ typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4,
+ Param5, Param6);
FunctionType func_;
public:
bool is_valid(){return func_ != 0;}
@@ -30,13 +33,15 @@
functor(generic_function_ptr func)
:func_(FunctionType(func))
{}
- ReturnValue operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)
+ 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>
+template <class ReturnValue, class Param1, class Param2, class Param3,
+ class Param4, class Param5>
class functor<ReturnValue, Param1, Param2, Param3, Param4, Param5>
{
protected:
@@ -56,7 +61,8 @@
}
};
-template <class ReturnValue, class Param1, class Param2, class Param3, class Param4>
+template <class ReturnValue, class Param1, class Param2, class Param3,
+ class Param4>
class functor<ReturnValue, Param1, Param2, Param3, Param4>
{
protected:
@@ -164,9 +170,13 @@
bool auto_close_;
public:
bool is_open(){return handle_ != 0;}
- static bool is_linkable_library(const char * file_name){return is_library(file_name);}
+ 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_);} template <class ReturnValue>
+ bool close(){return close_shared_library(handle_);}
+
+ template <class ReturnValue>
functor<ReturnValue>
get_functor(const char * function_name)
{
@@ -194,25 +204,29 @@
return functor<ReturnValue, Param1, Param2, Param3>
(get_function(handle_, function_name));
}
- template <class ReturnValue, class Param1, class Param2, class Param3, class Param4>
+ 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>
+ 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>
+ 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>
+ return functor<ReturnValue, Param1, Param2, Param3, Param4, Param5,
+ Param6>
(get_function(handle_, function_name));
}
shared_library(const char * location, bool auto_close = false)