From: mconsoni_at_[hidden]
Date: 2007-06-26 16:25:28
Author: mconsoni
Date: 2007-06-26 16:25:27 EDT (Tue, 26 Jun 2007)
New Revision: 7178
URL: http://svn.boost.org/trac/boost/changeset/7178
Log:
- replaced tabs with 8 spaces (as tabs aren't allowed by Boost Guidelines)
Text files modified:
sandbox/boost/extension/convenience.hpp | 7 +-
sandbox/boost/extension/counted_factory.hpp | 44 +++++++++---------
sandbox/boost/extension/counted_factory_map.hpp | 92 ++++++++++++++++++++--------------------
sandbox/boost/extension/extension.hpp | 2
sandbox/boost/extension/factory.hpp | 18 +++---
sandbox/boost/extension/factory_map.hpp | 76 ++++++++++++++++----------------
sandbox/boost/extension/filesystem.hpp | 12 ++--
sandbox/boost/extension/functor.hpp | 20 ++++----
sandbox/boost/extension/impl/library_impl.hpp | 22 ++++----
sandbox/boost/extension/impl/typeinfo.hpp | 2
sandbox/boost/extension/registry.hpp | 10 ++--
sandbox/boost/extension/shared_library.hpp | 20 ++++----
12 files changed, 163 insertions(+), 162 deletions(-)
Modified: sandbox/boost/extension/convenience.hpp
==============================================================================
--- sandbox/boost/extension/convenience.hpp (original)
+++ sandbox/boost/extension/convenience.hpp 2007-06-26 16:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,7 @@
/*
* Boost.Extension / convenience functions:
- * for now only one to load a library and register it in the factory map.
+ * 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
@@ -18,8 +19,8 @@
namespace boost{namespace extensions{
inline void load_single_library(factory_map & current_zone,
- const char * library_path,
- const char * external_function_name)
+ const char * library_path,
+ const char * external_function_name)
{
shared_library lib(library_path);
if (!lib.open())
Modified: sandbox/boost/extension/counted_factory.hpp
==============================================================================
--- sandbox/boost/extension/counted_factory.hpp (original)
+++ sandbox/boost/extension/counted_factory.hpp 2007-06-26 16:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,7 +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
@@ -16,8 +16,8 @@
#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>
+ class Param2 = void, class Param3 = void, class Param4 = void,
+ class Param5 = void, class Param6 = void>
class counted_factory
{
protected:
@@ -28,7 +28,7 @@
public:
virtual ~generic_factory_function(){}
virtual Interface * operator()(int * counter, Param1, Param2, Param3,
- Param4, Param5, Param6) = 0;
+ Param4, Param5, Param6) = 0;
virtual generic_factory_function * copy() const = 0;
};
template <class T>
@@ -41,8 +41,8 @@
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),
+ Param4 p4, Param5 p5, Param6 p6)
+ : T(p1, p2, p3, p4, p5, p6),
counter_(counter)
{
++(*counter_);
@@ -60,7 +60,7 @@
// 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));}
+ p4, p5, p6));}
virtual generic_factory_function * copy() const
{
return new factory_function<T>;
@@ -98,15 +98,15 @@
info_(first.info_)
{}
Interface * operator()(int * counter, Param1 p1, Param2 p2, Param3 p3,
- Param4 p4, Param5 p5, Param6 p6)
+ 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_)
+ 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 Param3, class Param4, class Param5>
class counted_factory<Interface, Info, Param1, Param2, Param3, Param4, Param5>
{
protected:
@@ -117,7 +117,7 @@
public:
virtual ~generic_factory_function(){}
virtual Interface * operator()(int * counter, Param1, Param2, Param3,
- Param4, Param5) = 0;
+ Param4, Param5) = 0;
virtual generic_factory_function * copy() const = 0;
};
template <class T>
@@ -130,7 +130,7 @@
int * counter_;
public:
counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3,
- Param4 p4, Param5 p5) : T(p1, p2, p3, p4, p5),
+ Param4 p4, Param5 p5) : T(p1, p2, p3, p4, p5),
counter_(counter)
{
++(*counter_);
@@ -147,7 +147,7 @@
// 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));}
+ p4, p5));}
virtual generic_factory_function * copy() const {
return new factory_function<T>;
}
@@ -183,7 +183,7 @@
info_(first.info_)
{}
Interface * operator()(int * counter, Param1 p1, Param2 p2, Param3 p3,
- Param4 p4, Param5 p5)
+ 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);
@@ -191,7 +191,7 @@
Info & get_info(){return info_;}
};
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4>
+ class Param3, class Param4>
class counted_factory<Interface, Info, Param1, Param2, Param3, Param4>
{
protected:
@@ -202,7 +202,7 @@
public:
virtual ~generic_factory_function(){}
virtual Interface * operator()(int * counter, Param1, Param2, Param3,
- Param4) = 0;
+ Param4) = 0;
virtual generic_factory_function * copy() const = 0;
};
template <class T>
@@ -215,7 +215,7 @@
int * counter_;
public:
counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3,
- Param4 p4) : T(p1, p2, p3, p4),
+ Param4 p4) : T(p1, p2, p3, p4),
counter_(counter)
{
++(*counter_);
@@ -232,7 +232,7 @@
// 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));}
+ p4));}
virtual generic_factory_function * copy() const {
return new factory_function<T>;
}
@@ -269,7 +269,7 @@
info_(first.info_)
{}
Interface * operator()(int * counter, Param1 p1, Param2 p2, Param3 p3,
- Param4 p4)
+ 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);
@@ -277,7 +277,7 @@
Info & get_info(){return info_;}
};
template <class Interface, class Info, class Param1, class Param2,
- class Param3>
+ class Param3>
class counted_factory<Interface, Info, Param1, Param2, Param3>
{
protected:
@@ -300,7 +300,7 @@
int * counter_;
public:
counted_object(int * counter, Param1 p1, Param2 p2, Param3 p3)
- : T(p1, p2, p3),
+ : T(p1, p2, p3),
counter_(counter)
{
++(*counter_);
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:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,6 @@
/*
* Boost.Extension / counted factory map:
- * map of factories (for the implementations) with a reference count
+ * map of factories (for the implementations) with a reference count
*
* (C) Copyright Jeremy Pack 2007
* Distributed under the Boost Software License, Version 1.0. (See
@@ -33,11 +33,11 @@
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 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> >,
+ Param4, Param5, Param6> >,
public generic_factory_container
{
public:
@@ -47,9 +47,9 @@
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();)
+ Param2, Param3, Param4, Param5, Param6> >::iterator it =
+ this->begin();
+ it != this->end();)
{
if (strcmp(it->library(), library_name) == 0)
this->erase(it++);
@@ -72,10 +72,10 @@
int * current_counter_;
public:
basic_counted_factory_map() : default_counter_(0),
- current_counter_(&default_counter_){}
+ current_counter_(&default_counter_){}
~basic_counted_factory_map(){
for(typename FactoryMap::iterator it = factories_.begin();
- it != factories_.end(); ++it)
+ it != factories_.end(); ++it)
delete it->second;
//TODO - test for memory leaks.
}
@@ -102,7 +102,7 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface,
- Info> &>(*(it->second));
+ Info> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info>
@@ -140,7 +140,7 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface, Info,
- Param1> &>(*(it->second));
+ Param1> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1>
@@ -172,7 +172,7 @@
{
factory_container<Interface, Info, Param1, Param2> * ret =
new factory_container<Interface, Info, Param1,
- Param2>(current_counter_);
+ Param2>(current_counter_);
factories_[current_type] = ret;
return *ret;
}
@@ -180,11 +180,11 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface, Info, Param1,
- Param2> &>(*(it->second));
+ Param2> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1,
- class Param2>
+ class Param2>
void add(Info info)
{
typedef std::list<counted_factory<Interface, Info, Param1, Param2> >
@@ -199,12 +199,12 @@
//it->set_type<Actual>();
}
template <class Interface, class Info, class Param1, class Param2,
- class Param3>
+ class Param3>
operator std::list<counted_factory<Interface, Info, Param1, Param2,
- Param3> > & ()
+ Param3> > & ()
{return this->get<Interface, Info, Param1, Param2, Param3>();}
template <class Interface, class Info, class Param1, class Param2,
- class Param3>
+ class Param3>
std::list<counted_factory<Interface, Info, Param1, Param2, Param3> > & get()
{
TypeInfo current_type =
@@ -217,7 +217,7 @@
{
factory_container<Interface, Info, Param1, Param2, Param3> * ret =
new factory_container<Interface, Info, Param1, Param2,
- Param3>(current_counter_);
+ Param3>(current_counter_);
factories_[current_type] = ret;
return *ret;
}
@@ -225,11 +225,11 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface, Info, Param1, Param2,
- Param3> &>(*(it->second));
+ Param3> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1,
- class Param2, class Param3>
+ class Param2, class Param3>
void add(Info info)
{
typedef std::list<counted_factory<Interface, Info, Param1, Param2,
@@ -244,14 +244,14 @@
//it->set_type<Actual>();
}
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4>
+ class Param3, class Param4>
operator std::list<counted_factory<Interface, Info, Param1, Param2, Param3,
- Param4> > & ()
+ Param4> > & ()
{return this->get<Interface, Info, Param1, Param2, Param3, Param4>();}
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4>
+ class Param3, class Param4>
std::list<counted_factory<Interface, Info, Param1, Param2, Param3,
- Param4> > & get()
+ Param4> > & get()
{
TypeInfo current_type =
type_info_handler<TypeInfo, counted_factory<Interface, Info, Param1,
@@ -262,9 +262,9 @@
if (it == factories_.end())
{
factory_container<Interface, Info, Param1, Param2, Param3,
- Param4> * ret =
+ Param4> * ret =
new factory_container<Interface, Info, Param1, Param2, Param3,
- Param4>(current_counter_);
+ Param4>(current_counter_);
factories_[current_type] = ret;
return *ret;
}
@@ -272,11 +272,11 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface, Info, Param1, Param2,
- Param3, Param4> &>(*(it->second));
+ Param3, Param4> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1,
- class Param2, class Param3, class Param4>
+ class Param2, class Param3, class Param4>
void add(Info info)
{
typedef std::list<counted_factory<Interface, Info, Param1, Param2,
@@ -292,17 +292,17 @@
//it->set_type<Actual>();
}
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4, class Param5>
+ class Param3, class Param4, class Param5>
operator std::list<counted_factory<Interface, Info, Param1, Param2, Param3,
- Param4, Param5> > & ()
+ 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>
+ class Param3, class Param4, class Param5>
std::list<counted_factory<Interface, Info, Param1, Param2, Param3, Param4,
- Param5> > & get()
+ Param5> > & get()
{
TypeInfo current_type =
type_info_handler<TypeInfo, counted_factory<Interface, Info, Param1,
@@ -312,18 +312,18 @@
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_);
+ 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));
+ Param3, Param4, Param5> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1,
- class Param2, class Param3, class Param4, class Param5>
+ class Param2, class Param3, class Param4, class Param5>
void add(Info info)
{
typedef std::list<counted_factory<Interface, Info, Param1, Param2,
@@ -340,15 +340,15 @@
//it->set_type<Actual>();
}
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4, class Param5, class Param6>
+ class Param3, class Param4, class Param5, class Param6>
operator std::list<counted_factory<Interface, Info, Param1, Param2, Param3,
- Param4, Param5, Param6> > & () {
+ Param4, Param5, Param6> > & () {
return this->get<Interface, Info, Param1, Param2, Param3, Param4, Param5,
- Param6>();}
+ Param6>();}
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4, class Param5, class Param6>
+ class Param3, class Param4, class Param5, class Param6>
std::list<counted_factory<Interface, Info, Param1, Param2, Param3, Param4,
- Param5, Param6> > & get()
+ Param5, Param6> > & get()
{
TypeInfo current_type =
type_info_handler<TypeInfo, counted_factory<Interface, Info, Param1,
@@ -358,9 +358,9 @@
if (it == factories_.end()) {
factory_container<Interface, Info, Param1, Param2, Param3, Param4,
- Param5, Param6> * ret =
+ Param5, Param6> * ret =
new factory_container<Interface, Info, Param1, Param2, Param3,
- Param4, Param5, Param6>(current_counter_);
+ Param4, Param5, Param6>(current_counter_);
factories_[current_type] = ret;
return *ret;
}
@@ -368,12 +368,12 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface, Info, Param1, Param2,
- Param3, Param4, Param5, Param6> &>(*(it->second));
+ 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>
+ class Param2, class Param3, class Param4, class Param5,
+ class Param6>
void add(Info info)
{
typedef std::list<counted_factory<Interface, Info, Param1, Param2,
Modified: sandbox/boost/extension/extension.hpp
==============================================================================
--- sandbox/boost/extension/extension.hpp (original)
+++ sandbox/boost/extension/extension.hpp 2007-06-26 16:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,6 @@
/*
* Boost.Extension / main header:
- * main header for extensions
+ * main header for extensions
*
* (C) Copyright Jeremy Pack 2007
* Distributed under the Boost Software License, Version 1.0. (See
Modified: sandbox/boost/extension/factory.hpp
==============================================================================
--- sandbox/boost/extension/factory.hpp (original)
+++ sandbox/boost/extension/factory.hpp 2007-06-26 16:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,6 @@
/*
* Boost.Extension / factory:
- * factory to register the implementations and create them
+ * factory to register the implementations and create them
*
* (C) Copyright Jeremy Pack 2007
* Distributed under the Boost Software License, Version 1.0. (See
@@ -15,8 +15,8 @@
#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>
+ class Param2 = void, class Param3 = void, class Param4 = void,
+ class Param5 = void, class Param6 = void>
class factory
{
protected:
@@ -25,7 +25,7 @@
public:
virtual ~generic_factory_function(){}
virtual Interface * operator()(Param1, Param2, Param3, Param4, Param5,
- Param6) = 0;
+ Param6) = 0;
virtual generic_factory_function * copy() const = 0;
};
template <class T>
@@ -58,17 +58,17 @@
info_(first.info_)
{}
Interface * operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4,
- Param5 p5, Param6 p6)
+ 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)
+ 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 Param3, class Param4, class Param5>
class factory<Interface, Info, Param1, Param2, Param3, Param4, Param5>
{
protected:
@@ -116,7 +116,7 @@
Info & get_info(){return info_;}
};
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4>
+ class Param3, class Param4>
class factory<Interface, Info, Param1, Param2, Param3, Param4>
{
protected:
@@ -164,7 +164,7 @@
Info & get_info(){return info_;}
};
template <class Interface, class Info, class Param1, class Param2,
- class Param3>
+ class Param3>
class factory<Interface, Info, Param1, Param2, Param3>
{
protected:
Modified: sandbox/boost/extension/factory_map.hpp
==============================================================================
--- sandbox/boost/extension/factory_map.hpp (original)
+++ sandbox/boost/extension/factory_map.hpp 2007-06-26 16:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,6 @@
/*
* Boost.Extension / factory map:
- * map of factories (for the implementations)
+ * map of factories (for the implementations)
*
* (C) Copyright Jeremy Pack 2007
* Distributed under the Boost Software License, Version 1.0. (See
@@ -32,12 +32,12 @@
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 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
+ Param2, Param3, Param4,
+ Param5, Param6> >,
+ public generic_factory_container
{
public:
factory_container() {}
@@ -59,7 +59,7 @@
public:
~basic_factory_map(){
for(typename FactoryMap::iterator it = factories_.begin();
- it != factories_.end(); ++it)
+ it != factories_.end(); ++it)
delete it->second;
//TODO - test for memory leaks.
}
@@ -85,7 +85,7 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface,
- Info> &>(*(it->second));
+ Info> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info>
@@ -121,7 +121,7 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface,
- Info, Param1> &>(*(it->second));
+ Info, Param1> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1>
@@ -158,11 +158,11 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface, Info, Param1,
- Param2> &>(*(it->second));
+ Param2> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1,
- class Param2>
+ class Param2>
void add(Info info)
{
typedef std::list<factory<Interface, Info, Param1, Param2> > ListType;
@@ -174,11 +174,11 @@
//it->set_type<Actual>();
}
template <class Interface, class Info, class Param1, class Param2,
- class Param3>
+ 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>
+ class Param3>
std::list<factory<Interface, Info, Param1, Param2, Param3> > & get()
{
TypeInfo current_type =
@@ -197,11 +197,11 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface, Info, Param1, Param2,
- Param3> &>(*(it->second));
+ Param3> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1,
- class Param2, class Param3>
+ class Param2, class Param3>
void add(Info info)
{
typedef std::list<factory<Interface, Info, Param1, Param2,
@@ -214,12 +214,12 @@
//it->set_type<Actual>();
}
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4>
+ class Param3, class Param4>
operator std::list<factory<Interface, Info, Param1, Param2, Param3,
- Param4> > & ()
+ Param4> > & ()
{return this->get<Interface, Info, Param1, Param2, Param3, Param4>();}
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4>
+ class Param3, class Param4>
std::list<factory<Interface, Info, Param1, Param2, Param3, Param4> > & get()
{
TypeInfo current_type =
@@ -230,8 +230,8 @@
if (it == factories_.end())
{
factory_container<Interface, Info, Param1, Param2, Param3,
- Param4> * ret = new factory_container<Interface, Info, Param1,
- Param2, Param3, Param4>();
+ Param4> * ret = new factory_container<Interface, Info, Param1,
+ Param2, Param3, Param4>();
factories_[current_type] = ret;
return *ret;
}
@@ -239,11 +239,11 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface, Info, Param1, Param2,
- Param3, Param4> &>(*(it->second));
+ Param3, Param4> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1, class
- Param2, class Param3, class Param4>
+ Param2, class Param3, class Param4>
void add(Info info)
{
typedef std::list<factory<Interface, Info, Param1, Param2, Param3,
@@ -257,15 +257,15 @@
//it->set_type<Actual>();
}
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4, class Param5>
+ class Param3, class Param4, class Param5>
operator std::list<factory<Interface, Info, Param1, Param2, Param3, Param4,
- Param5> > & ()
+ 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>
+ class Param3, class Param4, class Param5>
std::list<factory<Interface, Info, Param1, Param2, Param3, Param4,
- Param5> > & get()
+ Param5> > & get()
{
TypeInfo current_type =
type_info_handler<TypeInfo, factory<Interface, Info, Param1, Param2,
@@ -276,8 +276,8 @@
if (it == factories_.end())
{
factory_container<Interface, Info, Param1, Param2, Param3, Param4,
- Param5> * ret = new factory_container<Interface, Info, Param1,
- Param2, Param3, Param4, Param5>();
+ Param5> * ret = new factory_container<Interface, Info, Param1,
+ Param2, Param3, Param4, Param5>();
factories_[current_type] = ret;
return *ret;
}
@@ -285,11 +285,11 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface, Info, Param1, Param2,
- Param3, Param4, Param5> &>(*(it->second));
+ Param3, Param4, Param5> &>(*(it->second));
}
}
template <class Actual, class Interface, class Info, class Param1, class
- Param2, class Param3, class Param4, class Param5>
+ Param2, class Param3, class Param4, class Param5>
void add(Info info)
{
typedef std::list<factory<Interface, Info, Param1, Param2, Param3,
@@ -303,16 +303,16 @@
//it->set_type<Actual>();
}
template <class Interface, class Info, class Param1, class Param2,
- class Param3, class Param4, class Param5, class Param6>
+ class Param3, class Param4, class Param5, class Param6>
operator std::list<factory<Interface, Info, Param1, Param2, Param3,
- Param4, Param5, Param6> > & ()
+ 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>
+ class Param3, class Param4, class Param5, class Param6>
std::list<factory<Interface, Info, Param1, Param2, Param3, Param4,
- Param5, Param6> > & get()
+ Param5, Param6> > & get()
{
TypeInfo current_type = type_info_handler<TypeInfo, factory<Interface,
Info, Param1,
@@ -323,8 +323,8 @@
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>();
+ Param5, Param6> * ret = new factory_container<Interface, Info,
+ Param1, Param2, Param3, Param4, Param5, Param6>();
factories_[current_type] = ret;
return *ret;
}
@@ -332,11 +332,11 @@
{
// Change to dynamic if this fails
return static_cast<factory_container<Interface, Info, Param1, Param2,
- Param3, Param4, Param5, Param6> &>(*(it->second));
+ 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>
+ class Param2, class Param3, class Param4, class Param5, class Param6>
void add(Info info)
{
typedef std::list<factory<Interface, Info, Param1, Param2, Param3,
Modified: sandbox/boost/extension/filesystem.hpp
==============================================================================
--- sandbox/boost/extension/filesystem.hpp (original)
+++ sandbox/boost/extension/filesystem.hpp 2007-06-26 16:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,6 @@
/*
* Boost.Extension / filesystem functions:
- * functions to navigate folders/directories and get the libraries
+ * functions to navigate folders/directories and get the libraries
*
* (C) Copyright Jeremy Pack 2007
* Distributed under the Boost Software License, Version 1.0. (See
@@ -22,9 +22,9 @@
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)
+ 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;
@@ -35,12 +35,12 @@
if (is_directory(*file_iter))
{
load_all_libraries(current_zone, directory, file_iter->string().c_str(),
- max_depth - 1);
+ 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);
+ external_function_name);
}
}
}
Modified: sandbox/boost/extension/functor.hpp
==============================================================================
--- sandbox/boost/extension/functor.hpp (original)
+++ sandbox/boost/extension/functor.hpp 2007-06-26 16:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,7 +1,7 @@
/*
* Boost.Extension / functor:
- * functor used as the exported function of the libraries (the one that
- * registers the implementations at library loading time)
+ * functor used as the exported function of the libraries (the one that
+ * registers the implementations at library loading time)
*
* (C) Copyright Jeremy Pack 2007
* Distributed under the Boost Software License, Version 1.0. (See
@@ -66,12 +66,12 @@
#else
template <class ReturnValue, class Param1 = void, class Param2 = void,
- class Param3 = void, class Param4 = void, class Param5 = void,
- class Param6 = 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);
+ Param5, Param6);
FunctionType func_;
public:
@@ -86,19 +86,19 @@
{}
ReturnValue operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4,
- Param5 p5, Param6 p6)
+ 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 Param4, class Param5>
class functor<ReturnValue, Param1, Param2, Param3, Param4, Param5>
{
private:
typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4,
- Param5);
+ Param5);
FunctionType func_;
public:
@@ -111,14 +111,14 @@
:func_(FunctionType(func))
{}
ReturnValue operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4,
- Param5 p5)
+ Param5 p5)
{
return func_(p1, p2, p3, p4, p5);
}
};
template <class ReturnValue, class Param1, class Param2, class Param3,
- class Param4>
+ 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:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,6 @@
/*
* Boost.Extension / libraries management:
- * low-level platform specific dynamic library management
+ * low-level platform specific dynamic library management
*
* (C) Copyright Jeremy Pack 2007
* Distributed under the Boost Software License, Version 1.0. (See
@@ -31,13 +31,13 @@
{
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');
+ && 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) {
+ const char * function_name) {
return GetProcAddress(handle, function_name);
}
inline bool close_shared_library(library_handle handle) {
@@ -53,14 +53,14 @@
{
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-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-5] == 'd'
+ && file_name[len-4] == 'y'
+ && file_name[len-3] == 'l' &&
file_name[len-2] == 'i'
- && file_name[len-1] == 'b'));
+ && file_name[len-1] == 'b'));
}
}
#define BOOST_EXTENSION_LIBRARY_EXTENSION "dylib"
@@ -72,7 +72,7 @@
{
int len = strlen(file_name);
return (len > 2 && file_name[len-3] == '.' && file_name[len-2] == 's'
- && file_name[len-1] == 'o');
+ && file_name[len-1] == 'o');
}
}
#define BOOST_EXTENSION_LIBRARY_EXTENSION "so"
@@ -87,7 +87,7 @@
return dlopen(library_name, RTLD_LAZY);
}
inline generic_function_ptr get_function(library_handle handle,
- const char * function_name) {
+ const char * function_name) {
return dlsym(handle, function_name);
}
inline bool close_shared_library(library_handle handle) {
Modified: sandbox/boost/extension/impl/typeinfo.hpp
==============================================================================
--- sandbox/boost/extension/impl/typeinfo.hpp (original)
+++ sandbox/boost/extension/impl/typeinfo.hpp 2007-06-26 16:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,6 @@
/*
* Boost.Extension / typeinfo:
- * implementations name management with RTTI
+ * implementations name management with RTTI
*
* (C) Copyright Jeremy Pack 2007
* Distributed under the Boost Software License, Version 1.0. (See
Modified: sandbox/boost/extension/registry.hpp
==============================================================================
--- sandbox/boost/extension/registry.hpp (original)
+++ sandbox/boost/extension/registry.hpp 2007-06-26 16:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,6 @@
/*
* Boost.Extension / registry:
- * library registration (automates some operations)
+ * library registration (automates some operations)
*
* (C) Copyright Jeremy Pack 2007
* Distributed under the Boost Software License, Version 1.0. (See
@@ -53,8 +53,8 @@
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;
+ false),
+ int(0)))).first;
this->current_library_ = library_location;
this->current_counter_ = &it->second.second;
it->second.first.open();
@@ -64,7 +64,7 @@
}
functor<void, counted_factory_map &> load_func =
it->second.first.get_functor<void, counted_factory_map &>
- (function_name);
+ (function_name);
if (load_func.is_valid())
{
load_func(*this);
@@ -80,7 +80,7 @@
if (it == libraries_.end())
return false;
for (typename basic_counted_factory_map<TypeInfo>::FactoryMap::iterator it
- = this->factories_.begin(); it != this->factories_.end();) {
+ = 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:25:27 EDT (Tue, 26 Jun 2007)
@@ -1,6 +1,6 @@
/*
* Boost.Extension / shared_library:
- * functions for shared_library loading
+ * functions for shared_library loading
*
* (C) Copyright Jeremy Pack 2007
* Distributed under the Boost Software License, Version 1.0. (See
@@ -17,13 +17,13 @@
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>
+ class Param3 = void, class Param4 = void, class Param5 = void,
+ class Param6 = void>
class functor
{
protected:
typedef ReturnValue (*FunctionType)(Param1, Param2, Param3, Param4,
- Param5, Param6);
+ Param5, Param6);
FunctionType func_;
public:
bool is_valid(){return func_ != 0;}
@@ -34,14 +34,14 @@
:func_(FunctionType(func))
{}
ReturnValue operator()(Param1 p1, Param2 p2, Param3 p3, Param4 p4,
- Param5 p5, Param6 p6)
+ 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 Param4, class Param5>
class functor<ReturnValue, Param1, Param2, Param3, Param4, Param5>
{
protected:
@@ -62,7 +62,7 @@
};
template <class ReturnValue, class Param1, class Param2, class Param3,
- class Param4>
+ class Param4>
class functor<ReturnValue, Param1, Param2, Param3, Param4>
{
protected:
@@ -205,7 +205,7 @@
(get_function(handle_, function_name));
}
template <class ReturnValue, class Param1, class Param2, class Param3,
- class Param4>
+ class Param4>
functor<ReturnValue, Param1, Param2, Param3, Param4>
get_functor(const char * function_name)
{
@@ -213,7 +213,7 @@
(get_function(handle_, function_name));
}
template <class ReturnValue, class Param1, class Param2, class Param3,
- class Param4, class Param5>
+ class Param4, class Param5>
functor<ReturnValue, Param1, Param2, Param3, Param4, Param5>
get_functor(const char * function_name)
{
@@ -221,7 +221,7 @@
(get_function(handle_, function_name));
}
template <class ReturnValue, class Param1, class Param2, class Param3,
- class Param4, class Param5, class Param6>
+ class Param4, class Param5, class Param6>
functor<ReturnValue, Param1, Param2, Param3, Param4, Param5, Param6>
get_functor(const char * function_name)
{