Use variadic templates and forwarding references for better flexibility

diff --git a/source/loader.h b/source/loader.h
index 648c414cd2158b7d83983988f8027525b53940e6..b9eee50d8cde99b49fc897952580fa1d1695893e 100644 (file)
--- a/source/loader.h
+++ b/source/loader.h
@@ -85,10 +85,10 @@ protected:
        /** Loads a sub-object from the statement being processed with an extra
        parameter for the Loader.  The Loader class of the sub-object is
        automatically used. */
-       template<typename S, typename T>
-       void load_sub(S &s, T &p)
+       template<typename S, typename... Args>
+       void load_sub(S &s, Args &&... args)
        {
-               typename S::Loader ldr(s, p);
+               typename S::Loader ldr(s, std::forward<Args>(args)...);
                load_sub_with(ldr);
        }
 
@@ -119,6 +119,10 @@ protected:
        void add(const std::string &k, void (L::*func)(B0, Args...), const typename std::remove_reference<B0>::type &b0)
        { add(k, new LoaderFuncNBound1<L, B0, Args...>(func, b0)); }
 
+       template<typename L, typename B0, typename... Args>
+       void add(const std::string &k, void (L::*func)(B0, Args...), B0 &&b0)
+       { add(k, new LoaderFuncNBound1<L, B0, Args...>(func, std::forward<B0>(b0))); }
+
        /** Adds a keyword that is loaded into a member of the loaded object. */
        template<typename L, typename T0>
        void add(const std::string &k, T0 L::*p0)
@@ -161,12 +165,12 @@ Loads an object from a file.  The object must have a public Loader class.  Any
 extra arguments are passed to the Loader constructor.
 */
 template<typename T, typename... Args>
-void load(T &obj, const std::string &fn, Args &... args)
+void load(T &obj, const std::string &fn, Args &&... args)
 {
        IO::BufferedFile in(fn);
 
        Parser parser(in, fn);
-       typename T::Loader loader(obj, args...);
+       typename T::Loader loader(obj, std::forward<Args>(args)...);
        loader.load(parser);
 }
 
@@ -176,14 +180,14 @@ public Loader class.  The collection is passed to the Loader constructor,
 followed by any extra arguments.
 */
 template<typename T, typename... Args>
-void load(T &obj, typename T::Loader::Collection &coll, const std::string &fn, Args &... args)
+void load(T &obj, typename T::Loader::Collection &coll, const std::string &fn, Args &&... args)
 {
        RefPtr<IO::Seekable> in = coll.open_raw(fn);
        if(!in)
                throw IO::file_not_found(fn);
 
        Parser parser(*in, fn);
-       typename T::Loader loader(obj, coll, args...);
+       typename T::Loader loader(obj, coll, std::forward<Args>(args)...);
        loader.load(parser);
 }
 
@@ -192,14 +196,14 @@ Loads an object from a file stored in a collection.  The object must havea
 public Loader class.  Any extra arguments are passed to the Loader constructor.
 */
 template<typename T, typename C, typename... Args>
-typename std::enable_if<!NeedsCollection<typename T::Loader>::value>::type load(T &obj, C &coll, const std::string &fn, Args &... args)
+typename std::enable_if<!NeedsCollection<typename T::Loader>::value>::type load(T &obj, C &coll, const std::string &fn, Args &&... args)
 {
        RefPtr<IO::Seekable> in = coll.open_raw(fn);
        if(!in)
                throw IO::file_not_found(fn);
 
        Parser parser(*in, fn);
-       typename T::Loader loader(obj, args...);
+       typename T::Loader loader(obj, std::forward<Args>(args)...);
        loader.load(parser);
 }
 

diff --git a/source/loaderaction.h b/source/loaderaction.h
index 9d5baae63aa4de770a70eb7ef7a99f05f1099d43..23298428df659303185075b212c7ada5604d6778 100644 (file)
--- a/source/loaderaction.h
+++ b/source/loaderaction.h
@@ -174,15 +174,15 @@ template<unsigned I>
 struct Apply<I>
 {
        template<typename L, typename F, typename... Args>
-       static void apply(L &l, F func, const Statement &, Args... args)
+       static void apply(L &l, F func, const Statement &, Args &&... args)
        {
-               (l.*func)(args...);
+               (l.*func)(std::forward<Args>(args)...);
        }
 
        template<typename L, typename F, typename... Args>
-       static void apply(L &l, F func, const ArgumentStore &, Args... args)
+       static void apply(L &l, F func, const ArgumentStore &, Args &&... args)
        {
-               (l.*func)(args...);
+               (l.*func)(std::forward<Args>(args)...);
        }
 };
 
@@ -190,15 +190,15 @@ template<unsigned I, typename Head, typename... Tail>
 struct Apply<I, Head, Tail...>
 {
        template<typename L, typename F, typename... Args>
-       static void apply(L &l, F func, const Statement &st, Args... args)
+       static void apply(L &l, F func, const Statement &st, Args &&... args)
        {
-               Apply<I+1, Tail...>::apply(l, func, st, args..., st.args[I].get<Head>());
+               Apply<I+1, Tail...>::apply(l, func, st, std::forward<Args>(args)..., std::move(st.args[I].get<Head>()));
        }
 
        template<typename L, typename F, typename... Args>
-       static void apply(L &l, F func, const ArgumentStore &as, Args... args)
+       static void apply(L &l, F func, const ArgumentStore &as, Args &&... args)
        {
-               Apply<I+1, Tail...>::apply(l, func, as, args..., as.get<Head>(I));
+               Apply<I+1, Tail...>::apply(l, func, as, std::forward<Args>(args)..., std::move(as.get<Head>(I)));
        }
 };
 
@@ -240,7 +240,8 @@ protected:
        Bound0Type bound0;
 
 public:
-       LoaderFuncNBound1(FuncType f, const Bound0Type &b0): func(f), bound0(b0) { }
+       LoaderFuncNBound1(FuncType f, const B0 &b0): func(f), bound0(b0) { }
+       LoaderFuncNBound1(FuncType f, B0 &&b0): func(f), bound0(std::move(b0)) { }
 
        virtual void execute(Loader &l, const Statement &st) const
        {

diff --git a/source/objectloader.h b/source/objectloader.h
index 4c5dd020b722943fdd78fdcca067a67a565f12f5..978366f730e51cc197fe7dd20ab7f56f4b52e84e 100644 (file)
--- a/source/objectloader.h
+++ b/source/objectloader.h
@@ -42,10 +42,8 @@ public:
 protected:
        O &obj;
 
-       DerivedObjectLoader(O &o): B(o), obj(o) { }
-
-       template<typename T>
-       DerivedObjectLoader(O &o, T &a): B(o, a), obj(o) { }
+       template<typename... Args>
+       DerivedObjectLoader(O &o, Args &&... a): B(o, std::forward<Args>(a)...), obj(o) { }
 
 public:
        O &get_object() const { return obj; }

diff --git a/source/value.h b/source/value.h
index c272bcf81dc57b34e9e87f66112a997691aec282..bcddd6ed3aebb579256cd0a11061a76312a4a95c 100644 (file)
--- a/source/value.h
+++ b/source/value.h
@@ -18,12 +18,13 @@ private:
 
 public:
        template<typename T>
-       Value(T d):
+       Value(T &&d):
                sig(TypeInfo<T>::signature),
-               data(static_cast<typename TypeInfo<T>::Store>(d))
+               data(static_cast<typename TypeInfo<T>::Store>(std::forward<T>(d)))
        { }
 
-       Value(Symbol d): sig(TypeInfo<Symbol>::signature), data(d) { }
+       Value(const Symbol &d): sig(TypeInfo<Symbol>::signature), data(d) { }
+       Value(Symbol &&d): sig(TypeInfo<Symbol>::signature), data(std::move(d)) { }
 
        template<typename T>
        typename TypeInfo<T>::Load get() const