source: src/molecule_template.hpp@ 4455f4

Action_Thermostats Add_AtomRandomPerturbation Add_FitFragmentPartialChargesAction Add_RotateAroundBondAction Add_SelectAtomByNameAction Added_ParseSaveFragmentResults AddingActions_SaveParseParticleParameters Adding_Graph_to_ChangeBondActions Adding_MD_integration_tests Adding_ParticleName_to_Atom Adding_StructOpt_integration_tests AtomFragments Automaking_mpqc_open AutomationFragmentation_failures Candidate_v1.5.4 Candidate_v1.6.0 Candidate_v1.6.1 ChangeBugEmailaddress ChangingTestPorts ChemicalSpaceEvaluator CombiningParticlePotentialParsing Combining_Subpackages Debian_Package_split Debian_package_split_molecuildergui_only Disabling_MemDebug Docu_Python_wait EmpiricalPotential_contain_HomologyGraph EmpiricalPotential_contain_HomologyGraph_documentation Enable_parallel_make_install Enhance_userguide Enhanced_StructuralOptimization Enhanced_StructuralOptimization_continued Example_ManyWaysToTranslateAtom Exclude_Hydrogens_annealWithBondGraph FitPartialCharges_GlobalError Fix_BoundInBox_CenterInBox_MoleculeActions Fix_ChargeSampling_PBC Fix_ChronosMutex Fix_FitPartialCharges Fix_FitPotential_needs_atomicnumbers Fix_ForceAnnealing Fix_IndependentFragmentGrids Fix_ParseParticles Fix_ParseParticles_split_forward_backward_Actions Fix_PopActions Fix_QtFragmentList_sorted_selection Fix_Restrictedkeyset_FragmentMolecule Fix_StatusMsg Fix_StepWorldTime_single_argument Fix_Verbose_Codepatterns Fix_fitting_potentials Fixes ForceAnnealing_goodresults ForceAnnealing_oldresults ForceAnnealing_tocheck ForceAnnealing_with_BondGraph ForceAnnealing_with_BondGraph_continued ForceAnnealing_with_BondGraph_continued_betteresults ForceAnnealing_with_BondGraph_contraction-expansion FragmentAction_writes_AtomFragments FragmentMolecule_checks_bonddegrees GeometryObjects Gui_Fixes Gui_displays_atomic_force_velocity ImplicitCharges IndependentFragmentGrids IndependentFragmentGrids_IndividualZeroInstances IndependentFragmentGrids_IntegrationTest IndependentFragmentGrids_Sole_NN_Calculation JobMarket_RobustOnKillsSegFaults JobMarket_StableWorkerPool JobMarket_unresolvable_hostname_fix MoreRobust_FragmentAutomation ODR_violation_mpqc_open PartialCharges_OrthogonalSummation PdbParser_setsAtomName PythonUI_with_named_parameters QtGui_reactivate_TimeChanged_changes Recreated_GuiChecks Rewrite_FitPartialCharges RotateToPrincipalAxisSystem_UndoRedo SaturateAtoms_findBestMatching SaturateAtoms_singleDegree StoppableMakroAction Subpackage_CodePatterns Subpackage_JobMarket Subpackage_LinearAlgebra Subpackage_levmar Subpackage_mpqc_open Subpackage_vmg Switchable_LogView ThirdParty_MPQC_rebuilt_buildsystem TrajectoryDependenant_MaxOrder TremoloParser_IncreasedPrecision TremoloParser_MultipleTimesteps TremoloParser_setsAtomName Ubuntu_1604_changes stable
Last change on this file since 4455f4 was 4455f4, checked in by Frederik Heber <heber@…>, 16 years ago

Huge Refactoring: class atom split up into several inherited classes.
  • Property mode set to 100644
File size: 17.7 KB
Line 
1/*
2 * molecule_template.hpp
3 *
4 * Created on: Oct 6, 2009
5 * Author: heber
6 */
7
8#ifndef MOLECULE_TEMPLATE_HPP_
9#define MOLECULE_TEMPLATE_HPP_
10
11/*********************************************** includes ***********************************/
12
13// include config.h
14#ifdef HAVE_CONFIG_H
15#include <config.h>
16#endif
17
18/********************************************** declarations *******************************/
19
20// ================== Acting on all Vectors ========================== //
21
22// zero arguments
23template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() )
24{
25 atom *Walker = start;
26 while (Walker->next != end) {
27 Walker = Walker->next;
28 ((Walker->node)->*f)();
29 }
30};
31template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const )
32{
33 atom *Walker = start;
34 while (Walker->next != end) {
35 Walker = Walker->next;
36 ((Walker->node)->*f)();
37 }
38};
39template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() ) const
40 {
41 atom *Walker = start;
42 while (Walker->next != end) {
43 Walker = Walker->next;
44 ((Walker->node)->*f)();
45 }
46};
47template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const ) const
48 {
49 atom *Walker = start;
50 while (Walker->next != end) {
51 Walker = Walker->next;
52 ((Walker->node)->*f)();
53 }
54};
55// one argument
56template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t )
57{
58 atom *Walker = start;
59 while (Walker->next != end) {
60 Walker = Walker->next;
61 ((Walker->node)->*f)(t);
62 }
63};
64template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t )
65{
66 atom *Walker = start;
67 while (Walker->next != end) {
68 Walker = Walker->next;
69 ((Walker->node)->*f)(t);
70 }
71};
72template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t ) const
73{
74 atom *Walker = start;
75 while (Walker->next != end) {
76 Walker = Walker->next;
77 ((Walker->node)->*f)(t);
78 }
79};
80template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t ) const
81{
82 atom *Walker = start;
83 while (Walker->next != end) {
84 Walker = Walker->next;
85 ((Walker->node)->*f)(t);
86 }
87};
88// two arguments
89template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u )
90{
91 atom *Walker = start;
92 while (Walker->next != end) {
93 Walker = Walker->next;
94 ((Walker->node)->*f)(t, u);
95 }
96};
97template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u )
98{
99 atom *Walker = start;
100 while (Walker->next != end) {
101 Walker = Walker->next;
102 ((Walker->node)->*f)(t, u);
103 }
104};
105template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const
106{
107 atom *Walker = start;
108 while (Walker->next != end) {
109 Walker = Walker->next;
110 ((Walker->node)->*f)(t, u);
111 }
112};
113template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const
114{
115 atom *Walker = start;
116 while (Walker->next != end) {
117 Walker = Walker->next;
118 ((Walker->node)->*f)(t, u);
119 }
120};
121// three arguments
122template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v)
123{
124 atom *Walker = start;
125 while (Walker->next != end) {
126 Walker = Walker->next;
127 ((Walker->node)->*f)(t, u, v);
128 }
129};
130template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v)
131{
132 atom *Walker = start;
133 while (Walker->next != end) {
134 Walker = Walker->next;
135 ((Walker->node)->*f)(t, u, v);
136 }
137};
138template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const
139{
140 atom *Walker = start;
141 while (Walker->next != end) {
142 Walker = Walker->next;
143 ((Walker->node)->*f)(t, u, v);
144 }
145};
146template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const
147{
148 atom *Walker = start;
149 while (Walker->next != end) {
150 Walker = Walker->next;
151 ((Walker->node)->*f)(t, u, v);
152 }
153};
154
155// ========================= Summing over each Atoms =================================== //
156
157// zero arguments
158template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() )
159{
160 res result = 0;
161 atom *Walker = start;
162 while (Walker->next != end) {
163 Walker = Walker->next;
164 result += (Walker->*f)();
165 }
166 return result;
167};
168template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() const )
169{
170 res result = 0;
171 atom *Walker = start;
172 while (Walker->next != end) {
173 Walker = Walker->next;
174 result += (Walker->*f)();
175 }
176 return result;
177};
178template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() ) const
179{
180 res result = 0;
181 atom *Walker = start;
182 while (Walker->next != end) {
183 Walker = Walker->next;
184 result += (Walker->*f)();
185 }
186 return result;
187};
188template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() const ) const
189{
190 res result = 0;
191 atom *Walker = start;
192 while (Walker->next != end) {
193 Walker = Walker->next;
194 result += (Walker->*f)();
195 }
196 return result;
197};
198// one argument
199template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T), T t )
200{
201 res result = 0;
202 atom *Walker = start;
203 while (Walker->next != end) {
204 Walker = Walker->next;
205 result += (Walker->*f)(t);
206 }
207 return result;
208};
209template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T) const, T t )
210{
211 res result = 0;
212 atom *Walker = start;
213 while (Walker->next != end) {
214 Walker = Walker->next;
215 result += (Walker->*f)(t);
216 }
217 return result;
218};
219template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T), T t ) const
220{
221 res result = 0;
222 atom *Walker = start;
223 while (Walker->next != end) {
224 Walker = Walker->next;
225 result += (Walker->*f)(t);
226 }
227 return result;
228};
229template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T) const, T t ) const
230{
231 res result = 0;
232 atom *Walker = start;
233 while (Walker->next != end) {
234 Walker = Walker->next;
235 result += (Walker->*f)(t);
236 }
237 return result;
238};
239
240
241// ================== Acting with each Atoms on same molecule ========================== //
242
243// zero arguments
244template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *))
245{
246 atom *Walker = start;
247 while (Walker->next != end) {
248 Walker = Walker->next;
249 (*f)(Walker);
250 }
251};
252template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const)
253{
254 atom *Walker = start;
255 while (Walker->next != end) {
256 Walker = Walker->next;
257 (*f)(Walker);
258 }
259};
260template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
261{
262 atom *Walker = start;
263 while (Walker->next != end) {
264 Walker = Walker->next;
265 (*f)(Walker);
266 }
267};
268template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
269{
270 atom *Walker = start;
271 while (Walker->next != end) {
272 Walker = Walker->next;
273 (*f)(Walker);
274 }
275};
276
277// ================== Acting with each Atoms on copy molecule ========================== //
278
279// zero arguments
280template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy)
281{
282 atom *Walker = start;
283 while (Walker->next != end) {
284 Walker = Walker->next;
285 (copy->*f)(Walker);
286 }
287};
288template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const , molecule *copy)
289{
290 atom *Walker = start;
291 while (Walker->next != end) {
292 Walker = Walker->next;
293 (copy->*f)(Walker);
294 }
295};
296template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const
297{
298 atom *Walker = start;
299 while (Walker->next != end) {
300 Walker = Walker->next;
301 (copy->*f)(Walker);
302 }
303};
304template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
305{
306 atom *Walker = start;
307 while (Walker->next != end) {
308 Walker = Walker->next;
309 (copy->*f)(Walker);
310 }
311};
312
313// ================== Acting with each Atoms on copy molecule if true ========================== //
314
315// zero arguments
316template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () )
317{
318 atom *Walker = start;
319 while (Walker->next != end) {
320 Walker = Walker->next;
321 if ((Walker->*condition)())
322 (copy->*f)(Walker);
323 }
324};
325// one argument
326template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t )
327{
328 atom *Walker = start;
329 while (Walker->next != end) {
330 Walker = Walker->next;
331 if ((Walker->*condition)(t))
332 (copy->*f)(Walker);
333 }
334};
335// two arguments
336template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u )
337{
338 atom *Walker = start;
339 while (Walker->next != end) {
340 Walker = Walker->next;
341 if ((Walker->*condition)(t,u))
342 (copy->*f)(Walker);
343 }
344};
345// three arguments
346template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v )
347{
348 atom *Walker = start;
349 while (Walker->next != end) {
350 Walker = Walker->next;
351 if ((Walker->*condition)(t,u,v))
352 (copy->*f)(Walker);
353 }
354};
355
356// ================== Acting on all Atoms ========================== //
357
358// zero arguments
359template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)())
360{
361 atom *Walker = start;
362 while (Walker->next != end) {
363 Walker = Walker->next;
364 (Walker->*f)();
365 }
366};
367template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const)
368{
369 atom *Walker = start;
370 while (Walker->next != end) {
371 Walker = Walker->next;
372 (Walker->*f)();
373 }
374};
375template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)()) const
376{
377 atom *Walker = start;
378 while (Walker->next != end) {
379 Walker = Walker->next;
380 (Walker->*f)();
381 }
382};
383template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const) const
384{
385 atom *Walker = start;
386 while (Walker->next != end) {
387 Walker = Walker->next;
388 (Walker->*f)();
389 }
390};
391// one argument
392template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t )
393{
394 atom *Walker = start;
395 while (Walker->next != end) {
396 Walker = Walker->next;
397 (Walker->*f)(t);
398 }
399};
400template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t )
401{
402 atom *Walker = start;
403 while (Walker->next != end) {
404 Walker = Walker->next;
405 (Walker->*f)(t);
406 }
407};
408template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t ) const
409{
410 atom *Walker = start;
411 while (Walker->next != end) {
412 Walker = Walker->next;
413 (Walker->*f)(t);
414 }
415};
416template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t ) const
417{
418 atom *Walker = start;
419 while (Walker->next != end) {
420 Walker = Walker->next;
421 (Walker->*f)(t);
422 }
423};
424// two argument
425template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u )
426{
427 atom *Walker = start;
428 while (Walker->next != end) {
429 Walker = Walker->next;
430 (Walker->*f)(t, u);
431 }
432};
433template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u )
434{
435 atom *Walker = start;
436 while (Walker->next != end) {
437 Walker = Walker->next;
438 (Walker->*f)(t, u);
439 }
440};
441template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const
442{
443 atom *Walker = start;
444 while (Walker->next != end) {
445 Walker = Walker->next;
446 (Walker->*f)(t, u);
447 }
448};
449template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const
450{
451 atom *Walker = start;
452 while (Walker->next != end) {
453 Walker = Walker->next;
454 (Walker->*f)(t, u);
455 }
456};
457// three argument
458template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v)
459{
460 atom *Walker = start;
461 while (Walker->next != end) {
462 Walker = Walker->next;
463 (Walker->*f)(t, u, v);
464 }
465};
466template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v)
467{
468 atom *Walker = start;
469 while (Walker->next != end) {
470 Walker = Walker->next;
471 (Walker->*f)(t, u, v);
472 }
473};
474template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v) const
475{
476 atom *Walker = start;
477 while (Walker->next != end) {
478 Walker = Walker->next;
479 (Walker->*f)(t, u, v);
480 }
481};
482template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v) const
483{
484 atom *Walker = start;
485 while (Walker->next != end) {
486 Walker = Walker->next;
487 (Walker->*f)(t, u, v);
488 }
489};
490// four arguments
491template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w)
492{
493 atom *Walker = start;
494 while (Walker->next != end) {
495 Walker = Walker->next;
496 (Walker->*f)(t, u, v, w);
497 }
498};
499template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w)
500{
501 atom *Walker = start;
502 while (Walker->next != end) {
503 Walker = Walker->next;
504 (Walker->*f)(t, u, v, w);
505 }
506};
507template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w) const
508{
509 atom *Walker = start;
510 while (Walker->next != end) {
511 Walker = Walker->next;
512 (Walker->*f)(t, u, v, w);
513 }
514};
515template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w) const
516{
517 atom *Walker = start;
518 while (Walker->next != end) {
519 Walker = Walker->next;
520 (Walker->*f)(t, u, v, w);
521 }
522};
523
524// ===================== Accessing arrays indexed by some integer for each atom ======================
525
526// for atom ints
527template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *) )
528{
529 atom *Walker = start;
530 int inc = 1;
531 while (Walker->next != end) {
532 Walker = Walker->next;
533 (*Setor) (&array[(Walker->*index)], &inc);
534 }
535};
536template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T value )
537{
538 atom *Walker = start;
539 while (Walker->next != end) {
540 Walker = Walker->next;
541 (*Setor) (&array[(Walker->*index)], &value);
542 }
543};
544template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T *value )
545{
546 atom *Walker = start;
547 while (Walker->next != end) {
548 Walker = Walker->next;
549 (*Setor) (&array[(Walker->*index)], value);
550 }
551};
552// for element ints
553template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) )
554{
555 atom *Walker = start;
556 int inc = 1;
557 while (Walker->next != end) {
558 Walker = Walker->next;
559 (*Setor) (&array[(Walker->type->*index)], &inc);
560 }
561};
562template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value )
563{
564 atom *Walker = start;
565 while (Walker->next != end) {
566 Walker = Walker->next;
567 (*Setor) (&array[(Walker->type->*index)], &value);
568 }
569};
570template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value )
571{
572 atom *Walker = start;
573 while (Walker->next != end) {
574 Walker = Walker->next;
575 (*Setor) (&array[(Walker->type->*index)], value);
576 }
577};
578
579template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(Vector &), Vector atom::*value )
580{
581 atom *Walker = start;
582 while (Walker->next != end) {
583 Walker = Walker->next;
584 array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
585 }
586};
587template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(Vector &), Vector &vect )
588{
589 atom *Walker = start;
590 while (Walker->next != end) {
591 Walker = Walker->next;
592 array[(Walker->*index)] = (Walker->*Setor) (vect);
593 }
594};
595
596template <typename T, typename typ, typename typ2> void molecule::SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value )
597{
598 atom *Walker = start;
599 while (Walker->next != end) {
600 Walker = Walker->next;
601 Walker->*value = array[(Walker->*index)];
602 //cout << Verbose(2) << *Walker << " gets " << (Walker->*value); << endl;
603 }
604};
605
606template <typename T, typename typ> void molecule::SetAtomValueToValue ( T value, T typ::*ptr )
607{
608 atom *Walker = start;
609 while (Walker->next != end) {
610 Walker = Walker->next;
611 Walker->*ptr = value;
612 //cout << Verbose(2) << *Walker << " gets " << (Walker->*ptr) << endl;
613 }
614};
615
616
617#endif /* MOLECULE_TEMPLATE_HPP_ */
Note: See TracBrowser for help on using the repository browser.