--- trunk/src/selection/SelectionEvaluator.cpp	2005/02/03 23:14:05	283
+++ trunk/src/selection/SelectionEvaluator.cpp	2005/03/11 15:00:20	432
@@ -49,15 +49,20 @@ namespace oopse {
 namespace oopse {
 
 
-SelectionEvaluator::SelectionEvaluator(SimInfo* si, const std::string& script) : info(si), finder(info){
+SelectionEvaluator::SelectionEvaluator(SimInfo* si) 
+    : info(si), nameFinder(info), distanceFinder(info), indexFinder(info), isLoaded_(false){
+    
+    nStuntDouble = info->getNGlobalAtoms() + info->getNRigidBodies();
 }            
 
 bool SelectionEvaluator::loadScript(const std::string& filename, const std::string& script) {
+    clearDefinitionsAndLoadPredefined();
     this->filename = filename;
     this->script = script;
     if (! compiler.compile(filename, script)) {
         error = true;
         errorMessage = compiler.getErrorMessage();
+        std::cerr << "SelectionCompiler Error: " << errorMessage << std::endl;
         return false;
     }
 
@@ -65,13 +70,22 @@ bool SelectionEvaluator::loadScript(const std::string&
     aatoken = compiler.getAatokenCompiled();
     linenumbers = compiler.getLineNumbers();
     lineIndices = compiler.getLineIndices();
+
+    std::vector<std::vector<Token> >::const_iterator i;   
+
+    isDynamic_ = false;
+    for (i = aatoken.begin(); i != aatoken.end(); ++i) {
+        if (containDynamicToken(*i)) {
+            isDynamic_ = true;
+            break;
+        }
+    }
+
+    isLoaded_ = true;
     return true;
 }
 
 void SelectionEvaluator::clearState() {
-    for (int i = scriptLevelMax; --i >= 0; )
-        stack[i].clear();
-    scriptLevel = 0;
     error = false;
     errorMessage = "";
 }
@@ -87,11 +101,22 @@ bool SelectionEvaluator::loadScriptFileInternal(const 
 }
 
 bool SelectionEvaluator::loadScriptFileInternal(const  std::string & filename) {
-    return true; /**@todo */
+  std::ifstream ifs(filename.c_str());
+    if (!ifs.is_open()) {
+        return false;
+    }
+
+    const int bufferSize = 65535;
+    char buffer[bufferSize];
+    std::string script;
+    while(ifs.getline(buffer, bufferSize)) {
+        script += buffer;
+    }
+    return loadScript(filename, script);
 }
 
-void SelectionEvaluator::instructionDispatchLoop(){
-
+void SelectionEvaluator::instructionDispatchLoop(BitSet& bs){
+    
     while ( pc < aatoken.size()) {
         statement = aatoken[pc++];
         statementLength = statement.size();
@@ -101,20 +126,21 @@ void SelectionEvaluator::instructionDispatchLoop(){
                 define();
             break;
             case Token::select:
-                select();
+                select(bs);
             break;
             default:
                 unrecognizedCommand(token);
             return;
         }
     }
+
 }
 
   BitSet SelectionEvaluator::expression(const std::vector<Token>& code, int pcStart) {
     BitSet bs;
     std::stack<BitSet> stack;
     
-    for (int pc = pcStart; ; ++pc) {
+    for (int pc = pcStart; pc < code.size(); ++pc) {
       Token instruction = code[pc];
 
       switch (instruction.tok) {
@@ -154,6 +180,8 @@ void SelectionEvaluator::instructionDispatchLoop(){
       case Token::name:
         stack.push(nameInstruction(boost::any_cast<std::string>(instruction.value)));
         break;
+      case Token::index:
+        stack.push(indexInstruction(instruction.value));
         break;
       case Token::identifier:
         stack.push(lookupValue(boost::any_cast<std::string>(instruction.value)));
@@ -184,6 +212,7 @@ BitSet SelectionEvaluator::comparatorInstruction(const
     float comparisonValue = boost::any_cast<float>(instruction.value);
     float propertyValue;
     BitSet bs(nStuntDouble);
+    bs.clearAll();
     
     SimInfo::MoleculeIterator mi;
     Molecule* mol;
@@ -198,7 +227,6 @@ BitSet SelectionEvaluator::comparatorInstruction(const
             compareProperty(atom, bs, property, comparator, comparisonValue);
         }
         
-        //change the positions of atoms which belong to the rigidbodies
         for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
             compareProperty(rb, bs, property, comparator, comparisonValue);
         }        
@@ -208,17 +236,24 @@ void SelectionEvaluator::compareProperty(StuntDouble* 
 }
 
 void SelectionEvaluator::compareProperty(StuntDouble* sd, BitSet& bs, int property, int comparator, float comparisonValue) {
-        double propertyValue;
+        double propertyValue = 0.0;
         switch (property) {
         case Token::mass:
             propertyValue = sd->getMass();
             break;
         case Token::charge:
-            return;
-            //break;
-        case Token::dipole:
-            return;
-            //break; 
+            if (sd->isAtom()){
+                Atom* atom = static_cast<Atom*>(sd);
+                propertyValue = getCharge(atom);
+            } else if (sd->isRigidBody()) {
+                RigidBody* rb = static_cast<RigidBody*>(sd);
+                RigidBody::AtomIterator ai;
+                Atom* atom;
+                for (atom = rb->beginAtom(ai); atom != NULL; atom = rb->nextAtom(ai)) {
+                    propertyValue+=  getCharge(atom);
+                }
+            }
+            break;
         default:
             unrecognizedAtomProperty(property);
         }
@@ -250,14 +285,19 @@ void SelectionEvaluator::withinInstruction(const Token
 }
 
 void SelectionEvaluator::withinInstruction(const Token& instruction, BitSet& bs){
-
+    
     boost::any withinSpec = instruction.value;
+    float distance;
     if (withinSpec.type() == typeid(float)){
-        //
-        return;
+        distance = boost::any_cast<float>(withinSpec);
+    } else if (withinSpec.type() == typeid(int)) {
+        distance = boost::any_cast<int>(withinSpec);    
+    } else {
+        evalError("casting error in withinInstruction");
+        bs.clearAll();
     }
     
-    evalError("Unrecognized within parameter");
+    bs = distanceFinder.find(bs, distance);            
 }
 
 void SelectionEvaluator::define() {
@@ -265,7 +305,7 @@ void SelectionEvaluator::define() {
 
     std::string variable = boost::any_cast<std::string>(statement[1].value);
 
-    variables.insert(std::make_pair(variable, expression(statement, 2)));
+    variables.insert(VariablesType::value_type(variable, expression(statement, 2)));
 }
 
 
@@ -284,7 +324,7 @@ void SelectionEvaluator::predefine(const std::string& 
             int tok = statement[1].tok;
             if (tok == Token::identifier || (tok & Token::predefinedset) == Token::predefinedset) {
                 std::string variable = boost::any_cast<std::string>(statement[1].value);
-                variables.insert(std::make_pair(variable, statement));
+                variables.insert(VariablesType::value_type(variable, statement));
 
             } else {
                 evalError("invalid variable name:" + script);
@@ -301,34 +341,109 @@ void SelectionEvaluator::predefine(const std::string& 
 
 }
 
-void SelectionEvaluator::select(){
-    //viewer.setSelectionSet(expression(statement, 1));
+void SelectionEvaluator::select(BitSet& bs){
+    bs = expression(statement, 1);
 }
 
 BitSet SelectionEvaluator::lookupValue(const std::string& variable){
 
+    BitSet bs(nStuntDouble);
     std::map<std::string, boost::any>::iterator i = variables.find(variable);
-
+    
     if (i != variables.end()) {
         if (i->second.type() == typeid(BitSet)) {
             return boost::any_cast<BitSet>(i->second);
         } else if (i->second.type() ==  typeid(std::vector<Token>)){
-            BitSet bs = expression(boost::any_cast<std::vector<Token> >(i->second), 2);
+            bs = expression(boost::any_cast<std::vector<Token> >(i->second), 2);
             i->second =  bs; /**@todo fixme */
             return bs;
         }
     } else {
         unrecognizedIdentifier(variable);
     }
+
+    return bs;
 }
 
 BitSet SelectionEvaluator::nameInstruction(const std::string& name){
-    BitSet bs(nStuntDouble);
     
-    bool hasError = finder.match(name, bs);
-    
-    return bs;    
+    return nameFinder.match(name);
+
 }    
 
+bool SelectionEvaluator::containDynamicToken(const std::vector<Token>& tokens){
+    std::vector<Token>::const_iterator i;
+    for (i = tokens.begin(); i != tokens.end(); ++i) {
+        if (i->tok & Token::dynamic) {
+            return true;
+        }
+    }
 
+    return false;
+}    
+
+void SelectionEvaluator::clearDefinitionsAndLoadPredefined() {
+    variables.clear();
+    //load predefine
+    //predefine();
 }
+
+BitSet SelectionEvaluator::evaluate() {
+    BitSet bs(nStuntDouble);
+    if (isLoaded_) {
+        pc = 0;
+        instructionDispatchLoop(bs);
+    }
+
+    return bs;
+}
+
+BitSet SelectionEvaluator::indexInstruction(const boost::any& value) {
+    BitSet bs(nStuntDouble);
+
+    if (value.type() == typeid(int)) {
+        int index = boost::any_cast<int>(value);
+        if (index < 0 || index >= bs.size()) {
+            invalidIndex(index);
+        } else {
+            bs = indexFinder.find(index);
+        }
+    } else if (value.type() == typeid(std::pair<int, int>)) {
+        std::pair<int, int> indexRange= boost::any_cast<std::pair<int, int> >(value);
+        assert(indexRange.first <= indexRange.second);
+        if (indexRange.first < 0 || indexRange.second >= bs.size()) {
+            invalidIndexRange(indexRange);
+        }else {
+            bs = indexFinder.find(indexRange.first, indexRange.second);
+        }
+    }
+
+    return bs;
+}
+
+
+double SelectionEvaluator::getCharge(Atom* atom) {
+    double charge =0.0;
+    AtomType* atomType = atom->getAtomType();
+    if (atomType->isCharge()) {
+        GenericData* data = atomType->getPropertyByName("Charge");
+        if (data != NULL) {
+            DoubleGenericData* doubleData= dynamic_cast<DoubleGenericData*>(data);
+
+            if (doubleData != NULL) {
+                charge = doubleData->getData();
+
+            } else {
+                    sprintf( painCave.errMsg,
+                           "Can not cast GenericData to DoubleGenericData\n");
+                    painCave.severity = OOPSE_ERROR;
+                    painCave.isFatal = 1;
+                    simError();          
+            }
+        } 
+    }
+
+    return charge;
+}
+
+}