Created V0.3.x branch and moved the head into the trunk directory.

git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@246 b45a01b8-16f6-495d-af2f-9b41ad6348cc

libretroshare/src/rsiface/rsexpr.h

@@ -0,0 +1,241 @@
+#ifndef RS_EXPRESSIONS_H
+#define RS_EXPRESSIONS_H
+
+/*
+ * rs-core/src/rsiface: rsexpr.h
+ *
+ * RetroShare C++ Interface.
+ *
+ * Copyright 2007-2008 by Kashif Kaleem.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License Version 2 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA.
+ *
+ * Please report all bugs and problems to "retroshare@lunamutt.com".
+ *
+ */
+
+
+#include <string>
+#include <list>
+
+/******************************************************************************************
+Enumerations defining the Operators usable in the Boolean search expressions
+******************************************************************************************/
+
+
+enum LogicalOperator{
+	AndOp=0,	/* exp AND exp */
+	OrOp,		/* exp OR exp */
+	XorOp		/* exp XOR exp */
+};
+
+
+/*Operators for String Queries*/
+enum StringOperator{
+	ContainsAnyStrings = 0,	/* e.g. name contains any of 'conference' 'meeting' 'presentation' */
+	ContainsAllStrings,		/* same as above except that it contains ALL of the strings */
+	EqualsString			/* exactly equal*/
+};
+
+/*Relational operators ( >, <, >=, <=, == and InRange )*/
+enum RelOperator{
+	Equals = 0,
+	GreaterEquals,
+	Greater,
+	SmallerEquals,
+	Smaller,
+	InRange		/* lower limit <= value <= upper limit*/
+};
+
+/******************************************************************************************
+Boolean Search Expression
+classes:
+
+	Expression: 		The base class of all expression typest
+	CompoundExpression: The expression which uses a logical operator to combine
+							the results of two expressions
+	StringExpression: 	An expression which uses some sort of string comparison.
+	RelExpression: 		A Relational Expression where > < >= <= == make sense. 
+							e.g. size date etc
+
+******************************************************************************************/
+
+class FileEntry;
+
+class Expression{
+public:
+	virtual bool eval (FileEntry *file) = 0;
+	virtual ~Expression() {};
+};
+
+
+class CompoundExpression : public Expression {
+public:	
+	CompoundExpression( enum LogicalOperator op, Expression * exp1, Expression *exp2)
+						: Lexp(exp1), Rexp(exp2), Op(op){ }
+							
+	bool eval (FileEntry *file) {
+		if (Lexp == NULL or Rexp == NULL) {
+			return false;	
+		}
+		switch (Op){
+			case AndOp:
+				return Lexp->eval(file) && Rexp->eval(file);
+			case OrOp:
+				return Lexp->eval(file) || Rexp->eval(file);
+			case XorOp:
+				return Lexp->eval(file) ^ Rexp->eval(file);
+			default:
+				return false;
+		}
+	}
+	virtual ~CompoundExpression(){
+		delete Lexp;
+		delete Rexp;
+	}	
+private:
+	Expression *Lexp;
+	Expression *Rexp;
+	enum LogicalOperator Op;
+
+};
+
+class StringExpression: public Expression {
+public:
+	StringExpression(enum StringOperator op, std::list<std::string> &t, 
+					 bool ic): Op(op),terms(t), IgnoreCase(ic){}
+protected:
+	bool evalStr(std::string &str);
+private:
+	enum StringOperator Op;
+	std::list<std::string> terms;
+	bool IgnoreCase;
+};
+
+template <class T>
+class RelExpression: public Expression {
+public:	
+	RelExpression(enum RelOperator op, T lv, T hv): 
+				  Op(op), LowerValue(lv), HigherValue(hv) {}
+protected:
+	bool evalRel(T val);
+private:
+	enum RelOperator Op;
+	T LowerValue;
+	T HigherValue;
+};
+
+template <class T>
+bool RelExpression<T>::evalRel(T val) {
+	switch (Op) {
+		case Equals:
+			return LowerValue == val;
+		case GreaterEquals:
+			return LowerValue >= val;
+		case Greater:
+			return LowerValue > val;
+		case SmallerEquals:
+			return LowerValue <= val;
+		case Smaller:
+			return LowerValue < val;
+		case InRange:
+			return (LowerValue <= val) && (val <= HigherValue);
+		default:
+			return false;
+	}
+}
+
+
+/******************************************************************************************
+Binary Predicate for Case Insensitive search 
+
+******************************************************************************************/
+/*Binary predicate for case insensitive character comparison.*/
+/*TODOS:
+ *Factor locales in the comparison
+ */
+struct CompareCharIC :
+                public std::binary_function< char , char , bool> {
+
+        bool operator () ( char ch1 , char ch2 ) const {
+                return tolower( static_cast < unsigned char > (ch1) )
+                        == tolower( static_cast < unsigned char > (ch2) );
+        }
+
+};
+
+/******************************************************************************************
+Some implementations of StringExpressions. 
+
+******************************************************************************************/
+
+class NameExpression: public StringExpression {
+public:
+	NameExpression(enum StringOperator op, std::list<std::string> &t, bool ic): 
+					StringExpression(op,t,ic) {}
+	bool eval(FileEntry *file);
+};
+
+class PathExpression: public StringExpression {
+public:
+	PathExpression(enum StringOperator op, std::list<std::string> &t, bool ic): 
+					StringExpression(op,t,ic) {}
+	bool eval(FileEntry *file);
+};
+
+class ExtExpression: public StringExpression {
+public:
+	ExtExpression(enum StringOperator op, std::list<std::string> &t, bool ic): 
+					StringExpression(op,t,ic) {}
+	bool eval(FileEntry *file);
+};
+
+class HashExpression: public StringExpression {
+public:
+	HashExpression(enum StringOperator op, std::list<std::string> &t): 
+					StringExpression(op,t, true) {}
+	bool eval(FileEntry *file);
+};
+
+/******************************************************************************************
+Some implementations of Relational Expressions.
+
+******************************************************************************************/
+
+class DateExpression: public RelExpression<int> {
+public:
+	DateExpression(enum RelOperator op, int v): RelExpression<int>(op,v,v){}
+	DateExpression(enum RelOperator op, int lv, int hv): 
+					RelExpression<int>(op,lv,hv) {}
+	bool eval(FileEntry *file);
+};
+
+class SizeExpression: public RelExpression<int> {
+public:
+	SizeExpression(enum RelOperator op, int v): RelExpression<int>(op,v,v){}
+	SizeExpression(enum RelOperator op, int lv, int hv): 
+					RelExpression<int>(op,lv,hv) {}
+	bool eval(FileEntry *file);
+};
+
+class PopExpression: public RelExpression<int> {
+public:
+	PopExpression(enum RelOperator op, int v): RelExpression<int>(op,v,v){}
+	PopExpression(enum RelOperator op, int lv, int hv): 
+					RelExpression<int>(op,lv,hv) {}
+	bool eval(FileEntry *file);
+};
+
+#endif /* RS_EXPRESSIONS_H */