searchengine/cpix/cpix/inc/private/queryparser.h
changeset 8 6547bf8ca13a
child 24 65456528cac2
equal deleted inserted replaced
7:a5fbfefd615f 8:6547bf8ca13a
       
     1 /*
       
     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description: 
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #ifndef QUERYPARSER_H_
       
    20 #define QUERYPARSER_H_
       
    21 
       
    22 #include <memory>
       
    23 
       
    24 #include "CLucene.h"
       
    25 #include "CLucene/queryParser/MultiFieldQueryParser.h"
       
    26 
       
    27 #include "prefixopt.h"
       
    28 
       
    29 #include "cpixsearch.h"
       
    30 
       
    31 namespace Cpix {
       
    32 
       
    33 	class IQueryParser {
       
    34 		
       
    35 		public:
       
    36 		
       
    37 			virtual ~IQueryParser();
       
    38 		
       
    39 			virtual std::auto_ptr<lucene::search::Query> parse(const wchar_t* query) = 0;
       
    40 			
       
    41 			// Not really a fundamental property of a query parser:
       
    42 			virtual const wchar_t* getField() const = 0;
       
    43 			
       
    44 			virtual void setDefaultOperator(cpix_QP_Operator op) = 0;
       
    45 	};
       
    46 
       
    47 	class CLuceneQueryParser : public IQueryParser {
       
    48 		
       
    49 		public: 
       
    50 		
       
    51 			~CLuceneQueryParser();
       
    52 	
       
    53 			CLuceneQueryParser(const wchar_t* field, lucene::analysis::Analyzer& analyzer);
       
    54 			
       
    55 			virtual std::auto_ptr<lucene::search::Query> parse(const wchar_t* query);
       
    56 
       
    57 			virtual const wchar_t* getField() const;
       
    58 			
       
    59 			virtual void setDefaultOperator(cpix_QP_Operator op);
       
    60 
       
    61 		private: 
       
    62 			
       
    63 			std::auto_ptr<lucene::queryParser::QueryParser> parser_;  
       
    64 		
       
    65 	};
       
    66 	
       
    67 	class CLuceneMultiFieldQueryParser : public IQueryParser {
       
    68 		
       
    69 		public: 
       
    70 		
       
    71 			~CLuceneMultiFieldQueryParser();
       
    72 	
       
    73 			CLuceneMultiFieldQueryParser(const wchar_t** fields, 
       
    74 										 lucene::analysis::Analyzer& analyzer, 
       
    75 										 lucene::queryParser::BoostMap& boostMap);
       
    76 			
       
    77 			virtual std::auto_ptr<lucene::search::Query> parse(const wchar_t* query);
       
    78 			
       
    79 			virtual const wchar_t* getField() const;
       
    80 			
       
    81 			virtual void setDefaultOperator(cpix_QP_Operator op);
       
    82 			
       
    83 		private: 
       
    84 			
       
    85 			std::auto_ptr<lucene::queryParser::QueryParser> parser_;  
       
    86 		
       
    87 	};
       
    88 	
       
    89 
       
    90 	class PrefixOptQueryParser : public IQueryParser {
       
    91 		
       
    92 		public:
       
    93 		
       
    94 			PrefixOptQueryParser(std::auto_ptr<IQueryParser> parser);
       
    95 			
       
    96 			~PrefixOptQueryParser(); 
       
    97 			
       
    98 			virtual std::auto_ptr<lucene::search::Query> parse(const wchar_t* query);
       
    99 
       
   100 			virtual const wchar_t* getField() const;
       
   101 			
       
   102 			virtual void setDefaultOperator(cpix_QP_Operator op);
       
   103 
       
   104 		private:
       
   105 			
       
   106 			PrefixOptQueryRewriter prefixOpt_; 
       
   107 			
       
   108 			std::auto_ptr<IQueryParser> parser_;
       
   109 		
       
   110 	};
       
   111 	
       
   112 	// 
       
   113 	// Following factory methods apply necessary optimization wraps
       
   114 	// over the query parsers.
       
   115 	// 
       
   116 	
       
   117 	
       
   118 	IQueryParser* CreateCLuceneQueryParser(const wchar_t* defaultField, 
       
   119 									       lucene::analysis::Analyzer* analyzer);
       
   120 	
       
   121 	IQueryParser* CreateCLuceneMultiFieldQueryParser(
       
   122 											const wchar_t* fields[], 
       
   123 											lucene::analysis::Analyzer* analyzer, 
       
   124 											lucene::queryParser::BoostMap* boostMap);
       
   125 	
       
   126 	IQueryParser* CreatePrefixQueryParser(const wchar_t* field); 
       
   127 
       
   128 }
       
   129 
       
   130 #endif /* QUERYPARSER_H_ */