Re: msvc++ 2005 template question

here it comes:

25
26 #ifndef _eoPopulator_H
27 #define _eoPopulator_H
28
29 #include <eoPop.h>
30 #include <eoSelectOne.h>
31
32 /** eoPopulator is a helper class for general operators eoGenOp
33 It is an eoPop but also behaves like an eoPop::iterator
34 as far as operator* and operator++ are concerned
35
36 See eoGenOp and eoOpContainer
37 */
38 template <class EOT>
39 class eoPopulator
40 {
41 public :
42
43 eoPopulator(const eoPop<EOT>& _src, eoPop<EOT>& _dest) :
dest(_dest), current(dest.end()), src(_src)
44 {
45 dest.reserve(src.size()); // we don't know this, but wth.
46 current = dest.end();
47 }
48
49 /** @brief Virtual Constructor */
50 virtual ~eoPopulator() {};
51
52 struct OutOfIndividuals {};
53
54 /** a populator behaves like an iterator. Hence the operator*
55 * it returns the current individual -- eventually getting
56 * a new one through the operator++ if at the end
57 */
58 EOT& operator*(void)
59 {
60 if (current == dest.end())
61 get_next(); // get a new individual
62
63 return *current;
64 }
65
66 /** only prefix increment defined
67 Does not add a new element when at the end, use operator* for that
68 If not on the end, increment the pointer to the next individual
69 */
70 eoPopulator& operator++()
71 {
72 if (current == dest.end())
73 { // keep the pointer there
74 return *this;
75 }
76 // else
77 ++current;
78 return *this;
79 }
80
81 /** mandatory for operators that generate more offspring than parents
82 * if such a thing exists ?
83 */
84 void insert(const EOT& _eo)
85 { /* not really efficient, but its nice to have */
86 current = dest.insert(current, _eo);
87 }
88
89 /** just to make memory mangement more efficient
90 */
91 void reserve(int how_many)
92 {
93 size_t sz = current - dest.begin();
94 if (dest.capacity() < dest.size() + how_many)
95 {
96 dest.reserve(dest.size() + how_many);
97 }
98
99 current = dest.begin() + sz;
100 }
101
102 /** can be useful for operators with embedded selectors
103 * e.g. your brain and my beauty -type
104 */
105 const eoPop<EOT>& source(void) { return src; }
106
107 /** Get the offspring population.
108 Can be useful when you want to do some online niching kind of
thing
109 */
110 eoPop<EOT>& offspring(void) { return dest; }
111
112 typedef unsigned position_type;
113
114 /** this is a direct access container: tell position */
115 position_type tellp() { return current - dest.begin(); }
116 /** this is a direct access container: go to position */
117 void seekp(position_type pos) { current = dest.begin() + pos; }
118 /** no more individuals */
119 bool exhausted(void) { return current == dest.end(); }
120
121 /** the pure virtual selection method - will be instanciated in
122 * eoSeqPopulator and eoSelectivePopulator
123 */
124 virtual const EOT& select() = 0;
125
126 protected:
127 eoPop<EOT>& dest;
128 typename eoPop<EOT>::iterator current;
129 const eoPop<EOT>& src;
130
131 private:
132
133 void get_next() {
134 if(current == dest.end())
135 { // get new individual from derived class select()
136 dest.push_back(select());
137 current = dest.end();
138 --current;
139 return;
140 }
141 // else
142 ++current;
143 return;
144 }
145
146 };
147
148
149 /** SeqPopulator: an eoPopulator that sequentially goes through the
150 population is supposed to be used after a batch select of a whole
151 bunch or genitors
152 */
153 template <class EOT>
154 class eoSeqPopulator : public eoPopulator<EOT>
155 {
156 public:
157
158 using eoPopulator< EOT >::src;
159
160 eoSeqPopulator(const eoPop<EOT>& _pop, eoPop<EOT>& _dest) :
161 eoPopulator<EOT>(_pop, _dest), current(0) {}
162
163 /** the select method simply returns next individual in the src
pop */
164 const EOT& select(void) {
165 if(current >= eoPopulator< EOT >::src.size()) {
166 throw OutOfIndividuals();
167 }
168
169 const EOT& res = src[current++];
170 return res;
171 }
172
173
174 private:
175
176 struct OutOfIndividuals {};
177
178 unsigned current;
179 };
180
181
182 /** SelectivePopulator an eoPoplator that uses an eoSelectOne to
select guys.
183 Supposedly, it is passed the initial population.
184 */
185 template <class EOT>
186 class eoSelectivePopulator : public eoPopulator<EOT>
187 {
188 public :
189
190 using eoPopulator< EOT >::src;
191
192 eoSelectivePopulator(const eoPop<EOT>& _pop, eoPop<EOT>& _dest,
eoSelectOne<EOT>& _sel)
193 : eoPopulator<EOT>(_pop, _dest), sel(_sel)
194 { sel.setup(_pop); };
195
196 /** the select method actually selects one guy from the src pop */
197 const EOT& select() {
198 return sel(src);
199 }
200
201
202 private:
203
204 eoSelectOne<EOT>& sel;
205 };
206
207 #endif
208
209

Ben Voigt schrieb: