bool Unify::mgu(const Argument& arg1, const Argument& arg2, VariableMap& theta)
{
stack<pair<const Argument*, const Argument*> > S;
S.push(pair<const Argument*, const Argument*>(&arg1, &arg2));
while(!S.empty())
{
pair<const Argument*, const Argument*>& p = S.top();
S.pop();
const Argument* s = p.first;
const Argument* t = p.second;
VariableMap::iterator it;
while(s->IsVariable() && (it = theta.find(s)) != theta.end())
{
s = it->second;
}
while(t->IsVariable() && (it = theta.find(t)) != theta.end())
{
t = it->second;
}
if(s->IsVariable() && t->IsVariable())
{
if(s != t)
theta[s] = t;
}
else if(s->IsVariable())
{
theta[s] = t;
}
else if(t->IsVariable())
{
theta[t] = s;
}
else if(s->value == t->value)
{
if(s->args.size() != t->args.size()) return false;
for(size_t i = 0; i < s->args.size(); i++)
{
S.push(pair<const Argument*, const Argument*>(s->args[i], t->args[i]));
}
}
else return false;
}
return true;
}
VariableMap Argument::ConvertMapToArg(const Argument* arg,
const Argument* con_to,
const VariableMap& v_map)
{
VariableMap out;
stack<pair<const Argument*, const Argument*>> s;
s.emplace(arg, con_to);
while(!s.empty())
{
auto& tup = s.top();
const Argument* arg1 = get<0>(tup);
const Argument* arg2 = get<1>(tup);
s.pop();
if(arg1->t == Argument::Var)
{
out[arg2] = v_map.find(arg1)->second;
continue;
}
for(size_t i = 0;i < arg->args.size();i++)
{
s.emplace(arg2->args[i], arg2->args[i]);
}
}
return out;
}
bool Unify::IsGroundQuestion(const Argument* arg, const VariableMap& v_map)
{
std::stack<const Argument*> S;
S.push(arg);
while(!S.empty())
{
const Argument* temp = S.top();
S.pop();
if(temp->IsVariable())
{
VariableMap::const_iterator it;
while(temp->IsVariable() && (it = v_map.find(temp)) != v_map.end())
{
temp = it->second;
}
if(temp->IsVariable()) return false;
}
else for(size_t i = 0;i < temp->args.size();i++)
{
S.push(temp->args[i]);
}
}
return true;
}
Variables::VariableUsage *Variables::find(unsigned int varid)
{
if (varid) {
VariableMap::iterator i = _varUsage.find(varid);
if (i != _varUsage.end())
return &i->second;
}
return 0;
}
bool Unify::EquateWithSubstitution(const Argument& arg1,
const Argument& arg2,
const VariableMap& v_map)
{
typedef pair<const Argument*, const Argument*> ArgPair;
stack<ArgPair> S;
S.push(ArgPair(&arg1, &arg2));
while(!S.empty())
{
ArgPair& p = S.top();
S.pop();
const Argument* s = p.first;
const Argument* t = p.second;
if(s->IsVariable() && t->IsVariable())
{
S.push(ArgPair(v_map.find(s)->second, v_map.find(t)->second));
}
else if(s->IsVariable())
{
S.push(ArgPair(v_map.find(s)->second, t));
}
else if(t->IsVariable())
{
S.push(ArgPair(s, v_map.find(t)->second));
}
else if(s->value == t->value && s->args.size() == t->args.size())
{
for(size_t i = 0; i < s->args.size(); i++)
{
S.push(ArgPair(s->args[i], t->args[i]));
}
}
else return false;
}
return true;
}
Unify::VariableMap Unify::DecodeSubstitutions(const VariableMap& v_map,
const Argument* question,
const VariableMap& o_v_map,
list<Argument*>& to_del)
{
VariableMap out = o_v_map;
std::stack<const Argument*> S;
S.push(question);
while(!S.empty())
{
const Argument* t = S.top();
S.pop();
if(t->IsVariable())
{
const Argument* temp = t;
while(temp->IsVariable())
{
temp = v_map.find(temp)->second;
}
if(temp->HasVariables())
{
Argument* temp2 = Unify::GetSubstitutedArgument(temp, v_map);
to_del.push_back(temp2);
out[t] = temp2;
}
else out[t] = temp;
}
else
{
for(size_t i = 0;i < t->args.size();i++)
{
S.push(t->args[i]);
}
}
}
return out;
}
void Unify::SpecialMapCompression(VariableMap& v_map,
const VariableMap& e_map,
const VariableMap& o_v_map)
{
VariableMap out;
for(VariableMap::const_iterator it = e_map.begin();it != e_map.end();it++)
{
const Argument* temp = it->second;
if(temp->IsVariable())
{
temp = v_map.find(temp)->second;
}
out[it->first] = temp;
}
for(VariableMap::const_iterator it = o_v_map.begin();it != o_v_map.end();it++)
{
out[it->first] = it->second;
}
v_map = out;
}
std::string QueryMap::Apply(const VariableMap & vm, const Dictionary & dict
, SiteCharset charset)
{
using namespace std;
// split to vector
// find value in dict
stringstream ss;
UrlQueryEscape uqe;
vector<wstring> v;
boost::split(v, text_, boost::is_any_of(L"&"));
vector<pair<wstring, wstring> > w;
int i;
for (i=0; i<v.size(); ++i)
{
vector<wstring> eq;
boost::split(eq, v[i], boost::is_any_of(L"="));
if (eq.size() == 2)
w.push_back(make_pair(eq[0], eq[1]));
}
for (i=0; i<w.size(); ++i)
{
const wstring & key = w[i].first;
wstring domain = w[i].second, val;
// 1 find in vm, get value
// 2 find in dict, get value's value
if (boost::starts_with(domain, L"{")
&& boost::ends_with(domain, L"}") )
{
domain = domain.substr(1);
domain.resize(domain.size() - 1);
VariableMap::const_iterator i_vm = vm.find(domain);
ASSERT(i_vm != vm.end());
const VariableMap & vm_domain = dict.Find(domain);
if (!vm_domain.empty())
{
VariableMap::const_iterator j_vm = vm_domain.find(i_vm->second);
ASSERT(j_vm != vm_domain.end());
if (j_vm != vm_domain.end())
val = j_vm->second;
}
else
val = i_vm->second;
}
else
val = domain;
if (charset == SC_ANSI)
ss << w2string(key) << "=" << uqe(w2string(val)) << "&";
else
ss << string2utf8(key) << "=" << uqe(string2utf8(val)) << "&";
}
std::string ret = ss.str();
// remove last &
ret.resize(ret.size() - 1);
return ret;
}
