void ASPVariableQuery::createHeadQueryValues(vector<string> queryVec)
{
vector<string> valuesToParse;
for (auto queryString : queryVec)
{
auto vec = createHeadPredicates(queryString);
for (auto s : vec)
{
valuesToParse.push_back(s);
}
}
regex words_regex("[A-Z]+(\\w*)");
for (auto value : valuesToParse)
{
size_t begin = value.find("(");
size_t end = value.find(")");
string tmp = value.substr(begin, end - begin);
auto words_begin = sregex_iterator(tmp.begin(), tmp.end(), words_regex);
auto words_end = sregex_iterator();
while (words_begin != words_end)
{
smatch match = *words_begin;
string match_str = match.str();
tmp.replace(match.position(), match.length(), this->solver->WILDCARD_STRING);
words_begin = sregex_iterator(tmp.begin(), tmp.end(), words_regex);
}
value = value.replace(begin, end - begin, tmp);
stringstream ss;
ss << this->queryProgramSection << "(" << value << ")";
auto val = this->solver->parseValue(ss.str());
this->headValues.emplace(val, vector<Clingo::Symbol>());
}
}
vector<string> Utility::regex_Split(string& str, regex expr)
{
vector<string> out;
auto sbegin = sregex_iterator(begin(str), end(str), expr);
auto send = sregex_iterator();
for (auto i = sbegin; i != send; ++i)
{
out.emplace_back(i->str());
}
return out;
}
void DecisionStrategy::Init(const String &decisions){
_decisionWeights = new Vector<Vector<FeatureWeight>*>();
// decision:
regex decRegex("\\{d:(\\d+)(.*?)\\}");
// feature and weight
regex fwtRegex("\\(f:(\\d+) wt:(.*?)\\)");
Console::WriteLine("before convert:\n" + decisions);
std::string d(decisions.CString(), decisions.Length());
Console::WriteString("after convert:\n");
Console::WriteString(d.c_str());
Console::WriteLine("");
auto decBegin = sregex_iterator(d.begin(), d.end(), decRegex);
auto decEnd = sregex_iterator();
Console::WriteLine("Found num decisions:" + String(std::distance(decBegin, decEnd)));
// for each decision:
UINT dIndex = 0;
for (std::sregex_iterator it = decBegin; it != decEnd; ++it) {
std::smatch match = *it;
std::string match_dnum = match[1];
std::string match_dtext = match[2];
Console::WriteString("found decision:");
Console::WriteLine(match_dnum.c_str());
Console::WriteString("text:");
Console::WriteLine(match_dtext.c_str());
// add a vector to decision weights
_decisionWeights->PushEnd(new Vector<FeatureWeight>());
// for each feature weight:
auto featureBegin = sregex_iterator(match_dtext.begin(), match_dtext.end(), fwtRegex);
auto featureEnd = sregex_iterator();
Console::WriteLine("Found num fwts:" + String(std::distance(featureBegin, featureEnd)));
for (std::sregex_iterator itf = featureBegin; itf != featureEnd; ++itf) {
// get the matches
std::smatch fmatch = *itf;
std::string match_f = fmatch[1];
std::string match_wt = fmatch[2];
Console::WriteString("f:");
Console::WriteString(match_f.c_str());
Console::WriteString(" wt:");
Console::WriteString(match_wt.c_str());
Console::WriteString("\n");
// and add them!
Feature f = static_cast<Feature>(std::stoi(match_f));
double weight = std::stod(match_wt);
FeatureWeight fw(f, weight);
_decisionWeights->at(dIndex)->PushEnd(fw);
}
dIndex++;
}
}
void add_data_from_line(Memory& mem, string& line)
{
regex regex_apostrophe("'");
std::regex_replace(line, regex_apostrophe, "’");
regex regex_word("([a-zA-záéíóúñÁÉÍÓÚÑ'’]+)");
sregex_iterator find_word(line.begin(), line.end(), regex_word);
for (sregex_iterator find_end; find_word != find_end; ++find_word) {
string word_found = find_word->str();
word_found = to_lower_case(word_found);
update_word(mem.word_list, word_found);
}
vector<regex> regex_punc = {
regex("\\."),
regex(","),
regex(";"),
regex(":"),
regex("!"),
regex("\\?"),
regex("(?:[-–—]\\s*){1,2}"),
regex("…|(?:\\.\\s*){3}")
};
for (int i = 0; i < PUNC_NUM; ++i) {
sregex_iterator find_punc(line.begin(), line.end(), regex_punc[i]);
mem.punc_freq[i] += std::distance(find_punc, sregex_iterator());
}
regex regex_split_line("^([^.!?…]*[.!?…])?((?:[^.!?…]*[.!?…])*?)([^.!?…]*)$");
std::sregex_token_iterator split_line_prev(line.begin(), line.end(), regex_split_line, 1);
std::sregex_token_iterator split_line_cont(line.begin(), line.end(), regex_split_line, 2);
std::sregex_token_iterator split_line_xtra(line.begin(), line.end(), regex_split_line, 3);
string sentence_prev = *split_line_prev;
int sentence_prev_len = get_word_count(sentence_prev);
if (sentence_prev_len > 0) {
sentence_prev_len += mem.sentence_carry;
mem.sentence_len.push_back(sentence_prev_len);
mem.sentence_carry = 0;
}
string sentence_cont = *split_line_cont;
regex regex_split_sentence("([^\\.!?…]*)[\\.!?…]");
sregex_iterator find_sentence(sentence_cont.begin(), sentence_cont.end(), regex_split_sentence);
for (sregex_iterator find_end; find_sentence != find_end; ++find_sentence) {
string sentence_found = find_sentence->str();
int sentence_len = get_word_count(sentence_found);
mem.sentence_len.push_back(sentence_len);
mem.sentence_carry = 0;
}
string sentence_xtra = *split_line_xtra;
int sentence_xtra_len = get_word_count(sentence_xtra);
if (sentence_xtra_len > 0) {
mem.sentence_carry += sentence_xtra_len;
}
}
// Received new data:
void received(int id, asio::streambuf &readBuffer, std::size_t bytesTransferred)
{
string dataStr(boost::asio::buffer_cast<const char*>(readBuffer.data()), readBuffer.size());
string error;
//we're expecting a new request:
if (mState==REQUEST || mState==WAIT_LONGPOLL)
{
//if there is still an outstanding longpoll, cancel it:
if (mState==WAIT_LONGPOLL)
{
respond(true);
}
//resize data to first delimiter:
dataStr.resize(dataStr.find(delimiter)+delimiter.length());
readBuffer.consume(dataStr.length());
DEB(id << " got http REQUEST: \n" << dataStr);
//determine the kind of request:
smatch what;
if (!regex_search(
dataStr,
what,
boost::regex("^(GET|POST) ([^? ]*)([^ ]*) HTTP/(1..)$")
))
{
error="Cant parse request.";
}
else
{
mRequestType=what[1];
mRequestUrl=what[2];
mRequestQuery=what[3];
mRequestVersion=what[4];
DEB("REQUEST query: " << mRequestQuery);
//create a regex iterator for http headers
mHeaders.clear();
boost::sregex_iterator headerI(
dataStr.begin(),
dataStr.end(),
boost::regex("^([[:alnum:]-]*): (.*?)$")
);
//parse http headers
while (headerI!=sregex_iterator())
{
string header=(*headerI)[1].str();
string value=(*headerI)[2].str();
//headers handling is lowercase in synapse!
transform(header.begin(), header.end(), header.begin(), ::tolower);
mHeaders[header]=value;
headerI++;
}
//this header MUST be set on longpoll requests:
//if the client doesnt has one yet, httpSessionMan will assign a new one.
try
{
mAuthCookie=mHeaders["x-synapse-authcookie"];
}
catch(...)
{
mAuthCookie=0;
}
//proceed based on requestType:
//a GET or empty POST:
if (mRequestType=="GET" || (int)mHeaders["content-length"]==0)
{
if (respond())
{
mState=REQUEST;
}
else
{
DEB(id << " is now waiting for longpoll results");
mState=WAIT_LONGPOLL;
}
return;
}
//a POST with content:
else
{
if ( (int)mHeaders["content-length"]<0 || (int)mHeaders["content-length"] > config["maxContent"] )
{
error="Invalid Content-Length";
}
else
{
//change state to read the contents of the POST:
mState=CONTENT;
return;
}
}
}
}
else
//we're expecting the contents of a POST request.
if (mState==CONTENT)
{
if (readBuffer.size() < mHeaders["content-length"])
{
error="Didn't receive enough content-bytes!";
DEB(id << " ERROR: Expected " << mHeaders["content-length"].str() << " bytes, but only got: " << bytesTransferred);
}
else
{
dataStr.resize(mHeaders["content-length"]);
readBuffer.consume(mHeaders["content-length"]);
DEB(id << " got http CONTENT with length=" << dataStr.size() << ": \n" << dataStr);
//POST to the special send url?
if (mRequestUrl=="/synapse/send")
{
error=httpSessionMan.sendMessage(mAuthCookie, dataStr);
if (error=="")
{
//DONT:respond with jsondata if we have something in the queue anyways
//DONT:respondJsonQueue(false,false);
//we cant do this, because then the order of messages isnt garanteed. so just respond with a boring empty string:
respondString(200, "");
}
else
respondError(400, error);
mState=REQUEST;
return;
}
else
{
//ignore whatever is posted, and just respond normally:
DEB(id << " ignored POST content");
if (respond())
mState=REQUEST;
else
mState=WAIT_LONGPOLL;
return;
}
}
}
//ERROR(id << " had error while processing http data: " << error);
error="Bad request: "+error;
respondError(400, error);
doDisconnect();
return;
}
