source: nrEngine/include/VariadicArgument.h @ 18

Revision 18, 4.0 KB checked in by art, 13 years ago (diff)
Line 
1/***************************************************************************
2 *                                                                         *
3 *   (c) Art Tevs, MPI Informatik Saarbruecken                             *
4 *       mailto: <tevs@mpi-sb.mpg.de>                                      *
5 *                                                                         *
6 *   This program is free software; you can redistribute it and/or modify  *
7 *   it under the terms of the GNU General Public License as published by  *
8 *   the Free Software Foundation; either version 2 of the License, or     *
9 *   (at your option) any later version.                                   *
10 *                                                                         *
11 ***************************************************************************/
12
13#ifndef _NR_VARIADIC_ARGUMENT_H
14#define _NR_VARIADIC_ARGUMENT_H
15
16//----------------------------------------------------------------------------------
17// Includes
18//----------------------------------------------------------------------------------
19#include "Prerequisities.h"
20
21namespace nrEngine {
22
23        //! VariadicArgument - Class helping you to pass variable number of parameters to a scripting function
24        /**
25         * VariadicArgument - This class is usefull if you want to pass variable parameters to
26         * a function of a script. You can surely easy use the calling function,
27         * by providing a vector containing the data, but you have to create the vector
28         * before. Herewith you just write (Class << data1 << data2 ... ) to create
29         * temporary a list of contained data and pass it as an argument
30         *
31         * The variadic argument object could also be used to retrieve a resulting
32         * value from a function. Such a result value would contain more than one
33         * result which can then be casted to any type.
34         *
35         * \ingroup gp
36        **/
37        class _NRExport VarArg {
38       
39                public:
40                       
41                        //! Default constructor
42                        VarArg();
43
44                        //! Constructor getting any element
45                        VarArg(const boost::any& p);
46
47                        //! Copyconstructor
48                        VarArg(const VarArg& v);
49                       
50                        //! Fill the list with new element
51                        VarArg& operator, (const boost::any&);
52       
53                        //! Get access to certain element
54                        boost::any& operator[](int index);
55
56                        //! Get number of elements stored here
57                        uint32 size() const { return count; }
58
59                        //! Stack based function to retrieve the elements form the list
60                        boost::any pop_front();
61                       
62                        //! Stack based function to retrieve the elements form the list
63                        boost::any pop_back();
64
65                        //! Empty the resulting list
66                        void empty();
67                       
68                        //! Push new elements into the argument list
69                        void push_back(const boost::any&);
70                       
71                        //! Get an element of casted to a certain type
72                        template<class T> T get(int index){
73                                return cast<T>(_get(index));
74                        }
75                       
76                        //! Cast the element to a certain type
77                        template<class T> T cast(const boost::any& p){
78                                // we want to copy to the same type, so do nothing
79                                //if (p.type() == typeid(T) || typeid(T) == typeid(boost::any))
80                                //      return (T)p;
81                                       
82                                // in other cases, do any_cast and hope it works
83                                return boost::any_cast<T>(p);
84                        }
85
86                        //! Convert the variable argument list into a vector of certain type
87                        template<class T> void convert(std::vector<T>& v) const {
88                                v.clear();
89                                args::const_iterator it = mArgs.begin();
90                                for (int32 i=0; i < count; it++,i++){
91                                       
92                                        // we want to copy to the same type, so do nothing
93                                        if (it->type() == typeid(T)){
94                                                v.push_back(*it);
95
96                                        // we want to copy to type "any", so simple conversion
97                                        }else if (typeid(T) == typeid(boost::any)){
98                                                boost::any t = *it;
99                                                v.push_back(t);
100
101                                        // in other cases, do any_cast and hope it works
102                                        }else{
103                                                v.push_back (boost::any_cast<T>(*it));
104                                        }
105                                       
106                                }
107                                //return v;
108                        }
109                         
110                private:
111
112                        //! Type of the list we store the data in
113                        typedef std::list<boost::any> args;
114
115                        //! here we store our data
116                        args mArgs;
117
118                        //! here we store the number of elements
119                        int32 count;                   
120       
121                        //! Get access to certain element
122                        boost::any& _get(int index);
123
124        };
125
126};
127
128#endif
Note: See TracBrowser for help on using the repository browser.