C++primer 文本查询练习

// header file

#pragma once

#include "TextQuery.h"

#include <algorithm>

#include <iterator>

namespace StringQuery{

class QueryBase

{

friend class Query;

protected:

typedef TextQuery::line_no line_no;

virtual ~QueryBase(void){};

private:

virtual std::set<line_no> eval(const TextQuery& t) const = 0;

virtual std::ostream& display(std::ostream& os = std::cout) const = 0;

};

class Query

{

public:

friend Query operator~(const Query& );

friend Query operator|(const Query& ,const Query& );

friend Query operator&(const Query& ,const Query& );

std::set<TextQuery::line_no> eval(const TextQuery& tq) const

{

return q->eval(tq);

}

std::ostream& display(std::ostream& os) const

{

return q->display(os);

}

Query& operator=(const Query &);

public:

Query(const std::string &s);

Query(const Query& query):q(query.q),use(query.use){++*use;}

Query(QueryBase* qb):q(qb),use(new size_t(1)){}

~Query(void){decr_use();}

private:

QueryBase *q;

std::size_t *use;

inline void decr_use(void)

{

if(--*use==0)

{

delete q;

delete use;

}

}

};

inline std::ostream& operator<<(std::ostream& os,const Query &q)

{ return q.display(os); }

inline Query& Query::operator=(const Query &rhs)

{

++*rhs.use;

decr_use();

q = rhs.q;

use = rhs.use;

return *this;

}

class WordQuery:public QueryBase

{

friend class Query;

WordQuery(const std::string &s):query_word(s) { }

std::set<line_no> eval(const TextQuery &t) const

{ return t.run_query(query_word); }

std::ostream& display(std::ostream &os = std::cout) const

{ return os << query_word; }

std::string query_word;

};

inline

Query::Query(const std::string &s):q(new WordQuery(s)),

use(new std::size_t(1)) { }

class NotQuery:public QueryBase

{

friend Query operator~(const Query& query);

NotQuery(const Query& q):query(q) { }

std::set<line_no> eval(const TextQuery& file) const;

std::ostream& display(std::ostream& os = std::cout) const

{ return os << "~(" << query << ")"; }

const Query query;//implemente binding

};

class BinaryQuery:public QueryBase

{

protected:

BinaryQuery(const Query &rl,const Query &rr,const std::string &op):rhl(rl),rhr(rr),oper(op){}

std::ostream& display(std::ostream &os) const

{ return os << "~(" << rhl << "" << oper << " " << rhr << ")"; }

const Query rhl,rhr;

const std::string oper;

};

class OrQuery:public BinaryQuery

{

friend Query operator|(const Query &,const Query &);

OrQuery(const Query& rl,const Query& rr):BinaryQuery(rl,rr,"|"){}

std::set<line_no> eval(const TextQuery &file) const;

};

class AndQuery:public BinaryQuery

{

friend Query operator&(const Query &,const Query &);

AndQuery(const Query &rl,const Query &rr):BinaryQuery(rl,rr,"&"){}

std::set<line_no> eval(const TextQuery &file) const;

};

inline Query operator~(const Query& query)

{ return new NotQuery(query); }

inline Query operator|(const Query& query_left,const Query& query_right)

{ return new OrQuery(query_left,query_right); }

inline Query operator&(const Query& query_left,const Query& query_right)

{ return new AndQuery(query_left,query_right); }

Query parse_expression(const std::string &QueryString);

}

// cpp file

#include "Query.h"

#include "TextQuery.h"

#include <set>

#include <algorithm>

#include <iostream>

using std::set;

using std::vector;

using std::string;

using std::ostream;

using std::inserter;

using std::set_difference;

using std::set_union;

using std::set_intersection;

namespace StringQuery{

set<TextQuery::line_no> NotQuery::eval(const TextQuery &file) const

{

set<line_no> has_val = query.eval(file);

set<line_no> not_val;

for(line_no lineSum = 0;lineSum < file.size();++lineSum)

{

if( has_val.find(lineSum)==has_val.end() )

not_val.insert(lineSum);

}

return not_val;

}

set<TextQuery::line_no> OrQuery::eval(const TextQuery &file) const

{

set<line_no> right = rhr.eval(file),

ret_lines = rhl.eval(file);

ret_lines.insert( right.begin(),right.end() );

return ret_lines;

}

set<TextQuery::line_no> AndQuery::eval(const TextQuery &file) const

{

set<line_no> rval = rhr.eval(file),

lval = rhl.eval(file);

set<line_no> retlines;

set_intersection( rval.begin(),rval.end(),lval.begin(),lval.end(),inserter(retlines,retlines.begin()) );

return retlines;

}

bool inputValidate(const std::string &QueryString)

{

std::string::size_type pos = QueryString.find("~|&");

if(std::string::npos != pos)

if( std::string::npos != QueryString.find("~|&",++pos) )

return false;

return true;

}

Query parse_expression(const std::string &QueryString)

{

vector<string> words;

vector<string> opers;

string::size_type pos_pre = 0;

string::size_type pos_cur = QueryString.find_first_of("~|&");

while(string::npos != pos_cur)

{

string word = QueryString.substr( pos_pre,pos_cur - pos_pre );

words.push_back(word);

string oper = QueryString.substr(pos_cur,1);

opers.push_back(oper);

pos_pre = pos_cur+1;

pos_cur = QueryString.find_first_of("~|&",pos_pre);

}

string word = QueryString.substr(pos_pre,QueryString.size()-pos_pre);

words.push_back(word);

vector<string>::const_reverse_iterator words_it = words.rbegin();

vector<string>::const_reverse_iterator opers_it = opers.rbegin();

Query query(*words_it);

words_it++;

for(;words_it != words.rend();words_it++)

{

if( opers_it != opers.rend() )

{

switch((*opers_it).at(0))

{

case '~':

query = ~query;

break;

case '|':

query = query|Query(*words_it);

words_it++;

break;

case '&':

query = query&Query(*words_it);

words_it++;

break;

default:

std::cerr << "It's an operator from Mars!";

}

opers_it++;

}

}

//Query query( *(new string("temp")) );

return query;

}

}

// Finder.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include <conio.h>

#include "TextQuery.h"

#include "Query.h"

//#include <boost/regex.hpp>

//using namespace boost;

using std::string;

using std::set;

using std::cin;

using std::cout;

using std::endl;

void printResult(const string& word,const char* filename);

int _tmain(int argc, _TCHAR* argv[])

{

if(3 > argc)

{

cout << "Usage:program <Filename> <QueryWord> ." << endl;

}

else

{

string word;

for(int count = 2;count < argc;count++)

{

word += argv[count];

}

StringQuery::Query q( StringQuery::parse_expression(word) );

TextQuery tq;

tq.readFile(argv[1]);

q.display(std::cout);

set<TextQuery::line_no> rec = q.eval(tq);

set<TextQuery::line_no>::iterator it = rec.begin();

for(;it != rec.end();++it)

{

cout << " ( line " << *it << " ) " << tq.textLine(*it) << endl;

}

}

_getch();

return 0;

}

void printResult(const string& word,const char* filename)

{

TextQuery tq;

tq.readFile(filename);

set<TextQuery::line_no> res = tq.run_query(word);

cout << "Found " << res.size() << " items." << endl;

set<TextQuery::line_no>::iterator it = res.begin();

for(;it != res.end();++it)

{

cout << " ( line " << *it << " ) " << tq.textLine(*it) << endl;

}

}