# | Line 49 | Line 49 | namespace oopse { | |
---|---|---|
49 | namespace oopse { | |
50 | ||
51 | ||
52 | < | SelectionEvaluator::SelectionEvaluator(SimInfo* si) : info(si), finder(info), isLoaded_(false){ |
53 | < | |
52 | > | SelectionEvaluator::SelectionEvaluator(SimInfo* si) : info(si), nameFinder(info), distanceFinder(info), isLoaded_(false){ |
53 | > | nStuntDouble = info->getNGlobalAtoms() + info->getNRigidBodies(); |
54 | } | |
55 | ||
56 | bool SelectionEvaluator::loadScript(const std::string& filename, const std::string& script) { | |
# | Line 102 | Line 102 | bool SelectionEvaluator::loadScriptFileInternal(const | |
102 | } | |
103 | ||
104 | bool SelectionEvaluator::loadScriptFileInternal(const std::string & filename) { | |
105 | < | ifstream ifs(filename.c_str()); |
105 | > | std::ifstream ifs(filename.c_str()); |
106 | if (!ifs.is_open()) { | |
107 | return false; | |
108 | } | |
# | Line 181 | Line 181 | void SelectionEvaluator::instructionDispatchLoop(BitSe | |
181 | case Token::name: | |
182 | stack.push(nameInstruction(boost::any_cast<std::string>(instruction.value))); | |
183 | break; | |
184 | + | case Token::index: |
185 | + | stack.push(indexInstruction(instruction.value)); |
186 | break; | |
187 | case Token::identifier: | |
188 | stack.push(lookupValue(boost::any_cast<std::string>(instruction.value))); | |
# | Line 211 | Line 213 | BitSet SelectionEvaluator::comparatorInstruction(const | |
213 | float comparisonValue = boost::any_cast<float>(instruction.value); | |
214 | float propertyValue; | |
215 | BitSet bs(nStuntDouble); | |
216 | + | bs.clearAll(); |
217 | ||
218 | SimInfo::MoleculeIterator mi; | |
219 | Molecule* mol; | |
# | Line 277 | Line 280 | void SelectionEvaluator::withinInstruction(const Token | |
280 | } | |
281 | ||
282 | void SelectionEvaluator::withinInstruction(const Token& instruction, BitSet& bs){ | |
283 | < | |
283 | > | |
284 | boost::any withinSpec = instruction.value; | |
285 | + | float distance; |
286 | if (withinSpec.type() == typeid(float)){ | |
287 | < | // |
288 | < | return; |
287 | > | distance = boost::any_cast<float>(withinSpec); |
288 | > | } else if (withinSpec.type() == typeid(int)) { |
289 | > | distance = boost::any_cast<int>(withinSpec); |
290 | > | } else { |
291 | > | evalError("casting error in withinInstruction"); |
292 | > | bs.clearAll(); |
293 | } | |
294 | ||
295 | < | evalError("Unrecognized within parameter"); |
295 | > | bs = distanceFinder.find(bs, distance); |
296 | } | |
297 | ||
298 | void SelectionEvaluator::define() { | |
# | Line 292 | Line 300 | void SelectionEvaluator::define() { | |
300 | ||
301 | std::string variable = boost::any_cast<std::string>(statement[1].value); | |
302 | ||
303 | < | variables.insert(std::make_pair(variable, expression(statement, 2))); |
303 | > | variables.insert(VariablesType::value_type(variable, expression(statement, 2))); |
304 | } | |
305 | ||
306 | ||
# | Line 311 | Line 319 | void SelectionEvaluator::predefine(const std::string& | |
319 | int tok = statement[1].tok; | |
320 | if (tok == Token::identifier || (tok & Token::predefinedset) == Token::predefinedset) { | |
321 | std::string variable = boost::any_cast<std::string>(statement[1].value); | |
322 | < | variables.insert(std::make_pair(variable, statement)); |
322 | > | variables.insert(VariablesType::value_type(variable, statement)); |
323 | ||
324 | } else { | |
325 | evalError("invalid variable name:" + script); | |
# | Line 334 | Line 342 | BitSet SelectionEvaluator::lookupValue(const std::stri | |
342 | ||
343 | BitSet SelectionEvaluator::lookupValue(const std::string& variable){ | |
344 | ||
345 | + | BitSet bs(nStuntDouble); |
346 | std::map<std::string, boost::any>::iterator i = variables.find(variable); | |
347 | < | |
347 | > | |
348 | if (i != variables.end()) { | |
349 | if (i->second.type() == typeid(BitSet)) { | |
350 | return boost::any_cast<BitSet>(i->second); | |
351 | } else if (i->second.type() == typeid(std::vector<Token>)){ | |
352 | < | BitSet bs = expression(boost::any_cast<std::vector<Token> >(i->second), 2); |
352 | > | bs = expression(boost::any_cast<std::vector<Token> >(i->second), 2); |
353 | i->second = bs; /**@todo fixme */ | |
354 | return bs; | |
355 | } | |
356 | } else { | |
357 | unrecognizedIdentifier(variable); | |
358 | } | |
359 | + | |
360 | + | return bs; |
361 | } | |
362 | ||
363 | BitSet SelectionEvaluator::nameInstruction(const std::string& name){ | |
364 | ||
365 | < | return finder.match(name); |
365 | > | return nameFinder.match(name); |
366 | ||
367 | } | |
368 | ||
# | Line 375 | Line 386 | BitSet SelectionEvaluator::evaluate() { | |
386 | BitSet SelectionEvaluator::evaluate() { | |
387 | BitSet bs(nStuntDouble); | |
388 | if (isLoaded_) { | |
389 | + | pc = 0; |
390 | instructionDispatchLoop(bs); | |
391 | } | |
392 | ||
393 | return bs; | |
394 | } | |
395 | < | |
395 | > | |
396 | > | BitSet SelectionEvaluator::indexInstruction(const boost::any& value) { |
397 | > | BitSet bs(nStuntDouble); |
398 | > | |
399 | > | if (value.type() == typeid(int)) { |
400 | > | int index = boost::any_cast<int>(value); |
401 | > | if (index < 0 || index >= bs.size()) { |
402 | > | invalidIndex(index); |
403 | > | } else { |
404 | > | bs.setBitOn(index); |
405 | > | } |
406 | > | } else if (value.type() == typeid(std::pair<int, int>)) { |
407 | > | std::pair<int, int> indexRange= boost::any_cast<std::pair<int, int> >(value); |
408 | > | assert(indexRange.first <= indexRange.second); |
409 | > | if (indexRange.first < 0 || indexRange.second >= bs.size()) { |
410 | > | invalidIndexRange(indexRange); |
411 | > | }else { |
412 | > | bs.setRangeOn(indexRange.first, indexRange.second); |
413 | > | } |
414 | > | } |
415 | > | |
416 | > | return bs; |
417 | > | } |
418 | > | |
419 | //BitSet SelectionEvaluator::evaluate(int frameNo) { | |
420 | // | |
421 | //} |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |