Vegastrike 0.5.1 rc1  1.0
Original sources for Vegastrike Evolved
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | List of all members
Functor< TClass > Class Template Reference

#include <functors.h>

Inheritance diagram for Functor< TClass >:
TFunctor

Public Member Functions

virtual void * Call (std::vector< std::string > &d, int &sock_in, bool *isDown)
 
void nullify ()
 
 Functor (TClass *_pt2Object, void(TClass::*_fpt)())
 
 Functor (TClass *_pt2Object, void(TClass::*_fpt)(std::string &))
 
 Functor (TClass *_pt2Object, void(TClass::*_fpt)(const char *))
 
 Functor (TClass *_pt2Object, void(TClass::*_fpt)(const char *array[]))
 
 Functor (TClass *_Obj, void(TClass::*_fpt)(const char *, const char *))
 
 Functor (TClass *_Obj, void(TClass::*_fpt)(bool *))
 
 Functor (TClass *_Obj, void(TClass::*_fpt)(int))
 
 Functor (TClass *_Obj, void(TClass::*_fpt)(char))
 
 Functor (TClass *_Obj, void(TClass::*_fpt)(std::vector< std::string * > *d))
 
 Functor (TClass *_Obj, void(TClass::*_fpt)(std::vector< std::string * > *d, int &))
 
 Functor (TClass *_pt2Object, void(TClass::*_fpt)(std::string &, int &))
 
 Functor (TClass *_Obj, void(TClass::*_fpt)(std::vector< std::string * > *d, int &, bool))
 
virtual ~Functor ()
 
- Public Member Functions inherited from TFunctor
virtual ~TFunctor ()
 

Additional Inherited Members

- Public Attributes inherited from TFunctor
Attributes attribs
 

Detailed Description

template<class TClass>
class Functor< TClass >

Definition at line 58 of file functors.h.

Constructor & Destructor Documentation

template<class TClass>
Functor< TClass >::Functor ( TClass *  _pt2Object,
void(TClass::*)()  _fpt 
)
inline

Definition at line 210 of file functors.h.

211  {
212  nullify();
213  pt2Object = _pt2Object;
214  fpt1 = _fpt;
215  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _pt2Object,
void(TClass::*)(std::string &)  _fpt 
)
inline

Definition at line 217 of file functors.h.

218  {
219  nullify();
220  pt2Object = _pt2Object;
221  fpt2 = _fpt;
222  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _pt2Object,
void(TClass::*)(const char *)  _fpt 
)
inline

Definition at line 224 of file functors.h.

225  {
226  nullify();
227  pt2Object = _pt2Object;
228  fpt3 = _fpt;
229  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _pt2Object,
void(TClass::*)(const char *array[])  _fpt 
)
inline

Definition at line 230 of file functors.h.

231  {
232  nullify();
233  pt2Object = _pt2Object;
234  fpt4 = _fpt;
235  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _Obj,
void(TClass::*)(const char *, const char *)  _fpt 
)
inline

Definition at line 237 of file functors.h.

238  {
239  nullify();
240  pt2Object = _Obj;
241  fpt5 = _fpt;
242  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _Obj,
void(TClass::*)(bool *)  _fpt 
)
inline

Definition at line 244 of file functors.h.

245  {
246  nullify();
247  pt2Object = _Obj;
248  fpt6 = _fpt;
249  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _Obj,
void(TClass::*)(int)  _fpt 
)
inline

Definition at line 251 of file functors.h.

252  {
253  nullify();
254  pt2Object = _Obj;
255  fpt7 = _fpt;
256  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _Obj,
void(TClass::*)(char)  _fpt 
)
inline

Definition at line 258 of file functors.h.

259  {
260  nullify();
261  pt2Object = _Obj;
262  fpt8 = _fpt;
263  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _Obj,
void(TClass::*)(std::vector< std::string * > *d)  _fpt 
)
inline

Definition at line 265 of file functors.h.

266  {
267  nullify();
268  pt2Object = _Obj, fpt9 = _fpt;
269  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _Obj,
void(TClass::*)(std::vector< std::string * > *d, int &)  _fpt 
)
inline

Definition at line 271 of file functors.h.

272  {
273  nullify();
274  pt2Object = _Obj, fpt10 = _fpt;
275  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _pt2Object,
void(TClass::*)(std::string &, int &)  _fpt 
)
inline

Definition at line 277 of file functors.h.

278  {
279  nullify();
280  pt2Object = _pt2Object;
281  fpt11 = _fpt;
282  }
template<class TClass>
Functor< TClass >::Functor ( TClass *  _Obj,
void(TClass::*)(std::vector< std::string * > *d, int &, bool)  _fpt 
)
inline

Definition at line 284 of file functors.h.

285  {
286  nullify();
287  pt2Object = _Obj, fpt12 = _fpt;
288  }
template<class TClass>
virtual Functor< TClass >::~Functor ( )
inlinevirtual

Definition at line 291 of file functors.h.

291 {}

Member Function Documentation

template<class TClass>
virtual void* Functor< TClass >::Call ( std::vector< std::string > &  d,
int &  sock_in,
bool *  isDown 
)
inlinevirtual

Implements TFunctor.

Definition at line 79 of file functors.h.

80  {
81  //Comments {{{
82  //ok, d[0] == command typed
83  //d[1] == arg1
84  //d[2] == arg2, etc.
85  //sometimes socket can be ignored
86  //}}}
87  if (fpt1 != NULL) {
88  //fpt1() no args {{{
89  (*pt2Object.*fpt1)();
90  }
91  //}}}
92  else if (fpt2 != NULL) {
93  //fpt2(std::string &) {{{
94  std::string a;
95  unsigned int x;
96  for (x = 0; x < d.size(); x++) {
97  a.append( d[x] );
98  a.append( " " );
99  }
100  (*pt2Object.*fpt2)( a );
101  //}}}
102  } else if (fpt3 != NULL) {
103  //fpt3(const char *); {{{
104  if (d.size() >= 2)
105  (*pt2Object.*fpt3)( d[1].c_str() );
106  else (*pt2Object.*fpt3)( (const char*) NULL );
107  //}}}
108  } else if (fpt4 != NULL) {
109  //(const char *array[]); {{{
110  std::vector< const char* >buf;
111  for (unsigned int c = 0; c < d.size();) {
112  buf.push_back( d[c].c_str() );
113  c++;
114  if ( !( c < d.size() ) )
115  buf.push_back( " " );
116  }
117  (*pt2Object.*fpt4)( &buf[0] );
118  //}}}
119  } else if (fpt5 != NULL) {
120  //(const char *, const char *); {{{
121  if (d.size() < 2)
122  (*pt2Object.*fpt5)( (const char*) NULL, (const char*) NULL );
123  else if (d.size() < 3)
124  (*pt2Object.*fpt5)( d[1].c_str(), (const char*) NULL );
125  else
126  (*pt2Object.*fpt5)( d[1].c_str(), d[2].c_str() );
127  //}}}
128  } else if (fpt6 != NULL) {
129  //(bool *); {{{
130  (*pt2Object.*fpt6)( isDown );
131  }
132  //}}}
133  else if (fpt7 != NULL) {
134  //(int) {{{
135  if (d.size() < 2)
136  (*pt2Object.*fpt7)( 0 );
137  else
138  (*pt2Object.*fpt7)( atoi( d[1].c_str() ) );
139  //}}}
140  } else if (fpt8 != NULL) {
141  //(char) {{{
142  if (d.size() < 2) {
143  char err = 0;
144  (*pt2Object.*fpt8)( err );
145  } else {
146  (*pt2Object.*fpt8)( d[1][0] );
147  //}}}
148  }
149  } else if (fpt9 != NULL) {
150  //(std::vector<std::string *> *d) {{{
151  std::vector< std::string* >dup;
152  std::vector< std::string >::iterator ptr = d.begin();
153  while ( ptr < d.end() ) {
154  dup.push_back( &( *(ptr) ) );
155  ptr++;
156  }
157  (*pt2Object.*fpt9)( &dup );
158  //}}}
159  } else if (fpt10 != NULL) {
160  //(std::vector<std::string *> *d, int) {{{
161  std::vector< std::string* >dup;
162  std::vector< std::string >::iterator ptr = d.begin();
163  while ( ptr < d.end() ) {
164  dup.push_back( &( *(ptr) ) );
165  ptr++;
166  }
167  (*pt2Object.*fpt10)( &dup, sock_in );
168  //}}}
169  } else if (fpt11 != NULL) {
170  //(std::string &, int&); {{{
171  std::string a;
172  unsigned int x;
173  for (x = 0; x < d.size(); x++) {
174  a.append( d[x] );
175  a.append( " " );
176  }
177  (*pt2Object.*fpt11)( a, sock_in );
178  //}}}
179  } else if (fpt12 != NULL) {
180  //(std::vector<std::string *> *, int &, bool); // {{{
181  std::vector< std::string* >dup;
182  std::vector< std::string >::iterator ptr = d.begin();
183  while ( ptr < d.end() ) {
184  dup.push_back( &( *(ptr) ) );
185  ptr++;
186  }
187  (*pt2Object.*fpt12)( &dup, sock_in, false );
188  } //}}}
189  return &(attribs.m_return);
190 
191  return NULL;
192  } //}}}
template<class TClass>
void Functor< TClass >::nullify ( )
inline

Definition at line 193 of file functors.h.

Referenced by Functor< ShipCommands >::Functor().

194  {
195  //Set all the fpt's to null {{{
196  fpt1 = NULL;
197  fpt2 = NULL;
198  fpt3 = NULL;
199  fpt4 = NULL;
200  fpt5 = NULL;
201  fpt6 = NULL;
202  fpt7 = NULL;
203  fpt8 = NULL;
204  fpt9 = NULL;
205  fpt10 = NULL;
206  fpt11 = NULL;
207  fpt12 = NULL;
208  } //Nullify }}}
The documentation for this class was generated from the following file: