--- trunk/src/io/ParamConstraint.hpp	2005/10/14 14:48:10	667
+++ branches/development/src/io/ParamConstraint.hpp	2010/07/09 23:08:25	1465
@@ -6,19 +6,10 @@
  * redistribute this software in source and binary code form, provided
  * that the following conditions are met:
  *
- * 1. Acknowledgement of the program authors must be made in any
- *    publication of scientific results based in part on use of the
- *    program.  An acceptable form of acknowledgement is citation of
- *    the article in which the program was described (Matthew
- *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
- *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
- *    Parallel Simulation Engine for Molecular Dynamics,"
- *    J. Comput. Chem. 26, pp. 252-271 (2005))
- *
- * 2. Redistributions of source code must retain the above copyright
+ * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
- * 3. Redistributions in binary form must reproduce the above copyright
+ * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the
  *    distribution.
@@ -37,210 +28,356 @@
  * arising out of the use of or inability to use software, even if the
  * University of Notre Dame has been advised of the possibility of
  * such damages.
+ *
+ * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
+ * research, please cite the appropriate papers when you publish your
+ * work.  Good starting points are:
+ *                                                                      
+ * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
+ * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
+ * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
+ * [4]  Vardeman & Gezelter, in progress (2009).                        
  */
  
-#ifndef IO_PARAMCONSTRAINT_HPP
-#define IO_PARAMCONSTRAINT_HPP
-
-/**
-  * This class allows to recognize constraint predicates, so that they can be combined using
-  * composition operators. Every constraint predicate must be derived from this class
-  */
-template<typename Derived>
-struct ParamConstraintFacade {
-};
-
-
-struct NonConstraint : public ParamConstraintFacade<NonConstraint>{
-    template<typename DataType>
-    bool operator()( DataType data ) const {
-        return true;
-    }
-};
-
-struct NotEmptyConstraint : public ParamConstraintFacade<NotEmptyConstraint>{
-    bool operator()( const std::string data ) const {
-        return !data.empty();
-    }
-};
-
-struct ZeroConstraint : public ParamConstraintFacade<ZeroConstraint>{
-    template<typename DataType>
-    bool operator()( DataType data ) const
-    {
-        return data == 0;
-    }
-};
-
-struct NotZeroConstraint : public ParamConstraintFacade<NotZeroConstraint>{
-    template<typename DataType>
-    bool operator()( DataType data ) const
-    {
-        return data != 0;
-    }
-};
-
-struct PositiveConstraint : public ParamConstraintFacade<PositiveConstraint>{
-    template<typename DataType>
-    bool operator()( DataType data ) const
-    {
-        return data > 0;
-    }
-};
-
-struct NotPositiveConstraint : public ParamConstraintFacade<NotPositiveConstraint>{
-    template<typename DataType>
-    bool operator()( DataType data ) const
-    {
-        return data <= 0;
-    }
-};
-struct NotNegativeConstraint : public ParamConstraintFacade<NotNegativeConstraint>{
-    template<typename DataType>
-    bool operator()( DataType data ) const
-    {
-        return data >= 0;
-    }
-};
-
-struct NegativeConstraint : public ParamConstraintFacade<NegativeConstraint>{
-    template<typename DataType>
-    bool operator()( DataType data ) const
-    {
-        return data < 0;
-    }
-};
-
-struct NotNegativeConstraint : public ParamConstraintFacade<NotNegativeConstraint>{
-    template<typename DataType>
-    bool operator()( DataType data ) const
-    {
-        return true;
-    }
-};
-
-template<typename T>
-struct LessThanConstraint : public ParamConstraintFacade<LessThanConstraint> {
-    
-    LessThanConstraint(T rhs) : rhs_(rhs){}
-    template<typename DataType>
-    bool operator()( DataType data ) const {
-        return data < rhs_; 
-    }
-    private:
-        T rhs_;        
-};
-
-template<typename T>
-struct LessEqualConstraint : public ParamConstraintFacade<LessEqualConstraint> {
-    
-    LessEqualConstraint(T rhs) : rhs_(rhs){}
-    template<typename DataType>
-    bool operator()( DataType data ) const {
-        return data <= rhs_; 
-    }
-    private:
-        T rhs_;        
-};
-
-template<typename T>
-struct EqualConstraint : public ParamConstraintFacade<EqualConstraint> {
-    
-    EqualConstraint(T rhs) : rhs_(rhs){}
-    template<typename DataType>
-    bool operator()( DataType data ) const {
-        return data == rhs_; 
-    }
-    private:
-        T rhs_;        
-};
-
-// class_and composition predicate
-template<typename Cons1T, typename Cons2T>
-struct AndParamConstraint:
-    public ParamConstraintFacade< AndParamConstraint<Cons1T,Cons2T> > {
-public:
-
-    AndParamConstraint( Cons1T cons1, Cons2T cons2 ) :
-        cons1_(cons1, cons2_(cons2) {}
-
-    template<typename DataType>
-    bool operator()( DataType data ) const {
-        return cons1_(data) && cons2_(data);
-    }
-
-private:
-    Cons1T cons1_;
-    Cons2T cons2_;
-};
-
-
-
-template<typename Cons1T, typename Cons2T>
-struct OrParamConstraint:
-    public ParamConstraintFacade< OrParamConstraint<Cons1T,Cons2T> > {
-public:
-
-
-    OrParamConstraint( Cons1T cons1, Cons2T cons2 ) :
-        cons1_(cons1, cons2_(cons2) {}
-
-    template<typename DataType>
-    bool operator()( DataType data ) const {
-        return cons1_(data) || cons2_(data);
-    }
-
-private:
-    Cons1T cons1_;
-    Cons2T cons2_;
-};
-
-template<typename ConsT>
-struct NotParamConstraint:
-    public ParamConstraintFacade< NotParamConstraint<ConsT> >
-{
-public:
-
-
-    NotParamConstraint( ConsT cons) :
-        cons_(cons) {}
-
-    template<typename DataType>
-    bool operator()( DataType data ) const {
-        return !cons_(data);
-    }
-
-private:
-    ConsT cons_;
-};    
+#ifndef IO_PARAMCONSTRAINT_HPP
+#define IO_PARAMCONSTRAINT_HPP
+#include <sstream>
+#include "utils/CaseConversion.hpp"
+#include "utils/StringTokenizer.hpp"
+namespace OpenMD {
+  /**
+   * This class allows to recognize constraint predicates, so that they can be combined using
+   * composition operators. Every constraint predicate must be derived from this class
+   */
+  template<typename Derived>
+  struct ParamConstraintFacade {
+    std::string getConstraintDescription() {return description_;}
+  protected:
+    std::string description_;
+  };
 
-
-template<typename Cons1T, typename Cons2T>
-inline AndParamConstraint<Cons1T, Cons2T>
-operator &&(const ParamConstraintFacade<Cons1T>& cons1,  const ParamConstraintFacade<Cons2T>& cons2 ) {    
-
-    return AndParamConstraint<Cons1T,Cons2T>(
-        *static_cast<const Cons1T*>(&cons1), 
-        *static_cast<const Cons2T*>(&cons2) );
-}
-
-template<typename Cons1T, typename Cons2T>
-inline OrParamConstraint<Cons1T, Cons2T>
-operator ||( const ParamConstraintFacade<Cons1T>& cons1, const ParamConstraintFacade<Cons2T>& cons2 ) {    
-
-    return OrParamConstraint<Cons1T,Cons2T>(
-        *static_cast<const Cons1T*>(&cons1), 
-        *static_cast<const Cons2T*>(&cons2) );
-}
-
-
-template<typename ConsT>
-inline NotParamConstraint<ConsT>
-operator !( const ParamConstraintFacade<ConsT>& cons ) {
-
-    return NotParamConstraint<ConsT>(*static_cast<const ConsT*>(&cons)); 
-}
-
-
-
-#endif
+  struct NotEmptyConstraint : public ParamConstraintFacade<NotEmptyConstraint>{
+    
+    NotEmptyConstraint() { description_= "nonempty";}
+    bool operator()( const std::string data ) const {
+      return !data.empty();
+    }
+  };
+
+  struct ZeroConstraint : public ParamConstraintFacade<ZeroConstraint>{
+    
+    ZeroConstraint() {this->description_ = "zero";}
+    template<typename DataType>
+    bool operator()( DataType data ) const {
+      return data == 0;
+    }
+  };
+
+  struct NonZeroConstraint : public ParamConstraintFacade<NonZeroConstraint>{
+    NonZeroConstraint() {this->description_ = "nonzero";}
+
+    template<typename DataType>
+    bool operator()( DataType data ) const {
+      return data != 0;
+    }
+  };
+
+  struct PositiveConstraint : public ParamConstraintFacade<PositiveConstraint>{
+    PositiveConstraint() {this->description_ = "positive";}
+    template<typename DataType>
+    bool operator()( DataType data ) const
+    {
+      return data > 0;
+    }
+  };
+
+  struct NonPositiveConstraint : public ParamConstraintFacade<NonPositiveConstraint>{
+    NonPositiveConstraint() {this->description_ = "nonpositive";}
+    template<typename DataType>
+    bool operator()( DataType data ) const
+    {
+      return data <= 0;
+    }
+  };
+
+  struct NegativeConstraint : public ParamConstraintFacade<NegativeConstraint>{
+    NegativeConstraint() {this->description_ = "negative";}
+    template<typename DataType>
+    bool operator()( DataType data ) const
+    {
+      return data < 0;
+    }
+  };
+
+  struct NonNegativeConstraint : public ParamConstraintFacade<NonNegativeConstraint>{
+    NonNegativeConstraint() {this->description_ = "nonnegative";}
+    template<typename DataType>
+    bool operator()( DataType data ) const
+    {
+      return data >= 0;
+    }
+  };
+
+
+  struct EvenConstraint : public ParamConstraintFacade<EvenConstraint>{
+    EvenConstraint() {this->description_ = "even";}
+    template<typename DataType>
+    bool operator()( DataType data ) const
+    {
+      return data % 2 == 0;
+    }
+  };
+
+  template<typename T>
+  struct LessThanConstraint : public ParamConstraintFacade<LessThanConstraint<T> > {
+    
+    LessThanConstraint(T rhs) : rhs_(rhs){
+      std::stringstream iss;
+      iss << "less than " << rhs;
+      this->description_ = iss.str();
+    }
+    template<typename DataType>
+    bool operator()( DataType data ) const {
+      return data < rhs_; 
+    }
+  private:
+    T rhs_;        
+  };
+
+  template<typename T>
+  struct LessThanOrEqualToConstraint : public ParamConstraintFacade<LessThanOrEqualToConstraint<T> > {
+    
+    LessThanOrEqualToConstraint(T rhs) : rhs_(rhs) {
+      std::stringstream iss;
+      iss << "less than or equal to" << rhs;
+      this->description_ = iss.str();
+    }
+    
+    template<typename DataType>
+    bool operator()( DataType data ) const {
+      return data <= rhs_; 
+    }
+    
+  private:
+    T rhs_;        
+  };
+
+  template<typename T>
+  struct EqualConstraint : public ParamConstraintFacade<EqualConstraint<T> > {
+    
+    EqualConstraint(T rhs) : rhs_(rhs){
+      std::stringstream iss;
+      iss << "equal to" << rhs;
+      this->description_ = iss.str();
+
+    }
+    template<typename DataType>
+    bool operator()( DataType data ) const {
+      return data == rhs_; 
+    }
+  private:
+    T rhs_;        
+  };
+
+  struct EqualIgnoreCaseConstraint : public ParamConstraintFacade<EqualIgnoreCaseConstraint> {
+    
+    EqualIgnoreCaseConstraint(std::string rhs) : rhs_(OpenMD::toUpperCopy(rhs)){
+      std::stringstream iss;
+      iss << "equal to (case insensitive) " << rhs;
+      this->description_ = iss.str();
+    }
+    
+    bool operator()( std::string data ) const {
+      return OpenMD::toUpperCopy(data) == rhs_; 
+    }
+    
+  private:
+    std::string rhs_;        
+  };
+
+  struct ContainsConstraint :  public ParamConstraintFacade<EqualIgnoreCaseConstraint> {
+    ContainsConstraint(std::string rhs) : rhs_(OpenMD::toUpperCopy(rhs)){
+      std::stringstream iss;
+      iss << "contains " << rhs;
+      this->description_ = iss.str();
+    }
+    
+    bool operator()( std::string data ) const {
+      OpenMD::StringTokenizer tokenizer(OpenMD::toUpperCopy(data),  " ,;|\t\n\r");
+      while (tokenizer.hasMoreTokens()) {
+        if (tokenizer.nextToken() == rhs_) {
+          return true;
+        }
+      }
+        
+      return  false; 
+    }
+    
+  private:
+    std::string rhs_;        
+
+  };
+
+  template<typename T>
+  struct GreaterThanConstraint : public ParamConstraintFacade<GreaterThanConstraint<T> > {
+    
+    GreaterThanConstraint(T rhs) : rhs_(rhs){
+      std::stringstream iss;
+      iss << "greater than" << rhs;
+      this->description_ = iss.str();
+    }
+    template<typename DataType>
+    bool operator()( DataType data ) const {
+      return data > rhs_; 
+    }
+  private:
+    T rhs_;        
+  };
+
+  template<typename T>
+  struct GreaterThanOrEqualTo : public ParamConstraintFacade<GreaterThanOrEqualTo<T> > {
+    
+    GreaterThanOrEqualTo(T rhs) : rhs_(rhs){
+      std::stringstream iss;
+      iss << "greater than or equal to" << rhs;
+      this->description_ = iss.str();
+    }
+    template<typename DataType>
+    bool operator()( DataType data ) const {
+      return data >= rhs_; 
+    }
+  private:
+    T rhs_;        
+  };
+
+  // class_and composition predicate
+  template<typename Cons1T, typename Cons2T>
+  struct AndParamConstraint: public ParamConstraintFacade< AndParamConstraint<Cons1T,Cons2T> > {
+  public:
+
+    AndParamConstraint( Cons1T cons1, Cons2T cons2 ) : cons1_(cons1), cons2_(cons2) {
+      std::stringstream iss;
+      iss << "(" << cons1_.getConstraintDescription() << " and " << cons2_.getConstraintDescription() << ")"; 
+      this->description_ = iss.str();        
+    }
+
+    template<typename DataType>
+    bool operator()( DataType data ) const {
+      return cons1_(data) && cons2_(data);
+    }
+
+  private:
+    Cons1T cons1_;
+    Cons2T cons2_;
+  };
+
+
+
+  template<typename Cons1T, typename Cons2T>
+  struct OrParamConstraint: public ParamConstraintFacade< OrParamConstraint<Cons1T,Cons2T> > {
+  public:
+
+    OrParamConstraint( Cons1T cons1, Cons2T cons2 ) : cons1_(cons1), cons2_(cons2) {
+      std::stringstream iss;
+      iss << cons1_.getConstraintDescription() << " or " << cons2_.getConstraintDescription() << ""; 
+      this->description_ = iss.str(); 
+    }
+
+    template<typename DataType>
+    bool operator()( DataType data ) const {
+      return cons1_(data) || cons2_(data);
+    }
+
+  private:
+    Cons1T cons1_;
+    Cons2T cons2_;
+  };
+
+  template<typename ConsT>
+  struct NotParamConstraint: public ParamConstraintFacade< NotParamConstraint<ConsT> > {
+  public:
+
+
+    NotParamConstraint( ConsT cons) : cons_(cons) {
+      std::stringstream iss;
+      iss << "(not" << cons_.getConstraintDescription() << ")"; 
+      this->description_ = iss.str(); 
+    }
+
+    template<typename DataType>
+    bool operator()( DataType data ) const {
+      return !cons_(data);
+    }
+
+  private:
+    ConsT cons_;
+  };    
+
+
+  template<typename Cons1T, typename Cons2T>
+  inline AndParamConstraint<Cons1T, Cons2T>
+  operator &&(const ParamConstraintFacade<Cons1T>& cons1,  const ParamConstraintFacade<Cons2T>& cons2 ) {    
+
+    return AndParamConstraint<Cons1T,Cons2T>(
+                                             *static_cast<const Cons1T*>(&cons1), 
+                                             *static_cast<const Cons2T*>(&cons2) );
+  }
+
+  template<typename Cons1T, typename Cons2T>
+  inline OrParamConstraint<Cons1T, Cons2T>
+  operator ||( const ParamConstraintFacade<Cons1T>& cons1, const ParamConstraintFacade<Cons2T>& cons2 ) {    
+
+    return OrParamConstraint<Cons1T,Cons2T>(
+                                            *static_cast<const Cons1T*>(&cons1), 
+                                            *static_cast<const Cons2T*>(&cons2) );
+  }
+
+
+  template<typename ConsT>
+  inline NotParamConstraint<ConsT>
+  operator !( const ParamConstraintFacade<ConsT>& cons ) {
+
+    return NotParamConstraint<ConsT>(*static_cast<const ConsT*>(&cons)); 
+  }
+
+
+  NotEmptyConstraint isNotEmpty();
+  ZeroConstraint isZero();
+
+  ParamConstraintFacade<NonZeroConstraint> isNonZero();
+  PositiveConstraint isPositive();
+  NonPositiveConstraint isNonPositive();
+
+  NegativeConstraint isNegative();
+
+  NonNegativeConstraint isNonNegative();
+  EvenConstraint isEven();
+
+  template<typename T>
+  inline LessThanConstraint<T>isLessThan(T& v ) {
+    return LessThanConstraint<T>(v);
+  }
+
+  template<typename T>
+  inline LessThanOrEqualToConstraint<T> isLessThanOrEqualTo(T& v ) {
+    return ParamConstraintFacade<LessThanOrEqualToConstraint<T> >(v);
+  }
+
+  template<typename T>
+  inline EqualConstraint<T> isEqual(T& v ) {
+    return EqualConstraint<T>(v);
+  }
+
+  template<typename T>
+  inline GreaterThanConstraint<T> isGreaterThan(T& v ) {
+    return GreaterThanConstraint<T>(v);
+  }
+
+  template<typename T>
+  inline GreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(T& v ) {
+    return GreaterThanOrEqualTo<T>(v);
+  }
+
+  EqualIgnoreCaseConstraint isEqualIgnoreCase(std::string str);
+}
+#endif