context.cpp
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Tue, Jul 7, 4:36 PM

context.cpp
View Options

	/*
	* adhoc.cpp
	*
	* Created on: Dec 1, 2015
	* Author: pgess
	*/

	#include <query/context.h>
	#include <boost/range/iterator_range_core.hpp>
	#include <boost/iterator/transform_iterator.hpp>

	using namespace std;
	namespace xreate {

	ContextQuery::ContextQuery()
	: domainEmpty(vector<Expression>()) {}

	const ContextDomain&
	ContextQuery::getContext(const ScopePacked& scopeId){
	if (!__modelContext.count(scopeId)){
	return domainEmpty;
	}

	return __modelContext.at(scopeId);
	}

	const ContextDomain&
	ContextQuery::getContext(CodeScope* const scope){
	return getContext(clasp->pack(scope));
	}

	void
	ContextQuery::forceContext(const ScopePacked& scopeId, std::list<Expression> context){
	// TODO remove forced context of the same class/type only, possibly
	//remove any previous forced context for this scopeId
	//__modelForcedContext.erase(scopeId);

	//TASK restore forceContext
	//std::multimap<ScopePacked, Expression> __modelForcedContext;
	/*
	std::transform(context.begin(), context.end(), inserter(__modelForcedContext, __modelForcedContext.end()),
	[scopeId](const Expression& context){return make_pair(scopeId, context);});
	*/
	}

	void
	ContextQuery::init(ClaspLayer* clasp){
	const std::string& atomEarlyBinding = Config::get("clasp.bindings.scope");

	this->clasp = clasp;
	ClaspLayer::ModelFragment query = clasp->query(atomEarlyBinding);

	//static context
	if (query){
	map<ScopePacked, vector<Expression>> dictContext;

	for (auto i = query->first; i!=query->second; ++i){
	ScopePacked idScope;
	Expression context;
	tie(idScope, context) = ClaspLayer::parse<ScopePacked, Expression>(i->second);
	dictContext[idScope].push_back(context);
	}

	for (map<ScopePacked, vector<Expression>>::value_type& entry: dictContext){
	__modelContext.insert(move(entry));
	}
	}

	//static decisions
	query = clasp->query(Config::get("clasp.bindings.scope_decision"));
	if (query){
	for (auto i = query->first; i!=query->second; ++i){
	ScopePacked scopeId;
	string function;
	Expression specialization;
	tie(scopeId, function, specialization) = ClaspLayer::parse<ScopePacked, string, Expression>(i->second);
	ScopeContextDecisions& scope = __modelStaticDecisions[scopeId];
	assert(scope.emplace(function, specialization).second && "Possibly more than one decision");
	}
	}

	//Fetch function specialization domains
	std::multimap<string, Expression> modelDomains;
	const list<ManagedFnPtr>& functions = clasp->ast->getAllFunctions();
	for (auto f: functions){
	if (f->guardContext.isValid()){
	modelDomains.emplace(f->getName(), f->guardContext);
	}
	}

	auto adapter = [](const std::pair<const string&,const Expression>& p){ return p.second; };

	auto iBegin = modelDomains.begin();
	while (iBegin!=modelDomains.end()){
	string function = iBegin->first;
	auto iEnd = modelDomains.upper_bound(function);
	auto iBeginAdapted = boost::make_transform_iterator(iBegin,adapter);
	auto iEndAdapted = boost::make_transform_iterator(iEnd,adapter);
	ContextDomain dom(iBeginAdapted, iEndAdapted);
	__modelFunctionDomain.emplace(function, move(dom));
	iBegin = iEnd;
	}

	prepareDemandModel();
	}

	const ContextDomain&
	ContextQuery::getFunctionDomain(const std::string& name) const {
	if (__modelFunctionDomain.count(name)){
	return __modelFunctionDomain.at(name);
	}

	return domainEmpty;
	}

	const FunctionContextDemand&
	ContextQuery::getFunctionDemand(const std::string& name) const {
	if (__modelFunctionDemand.count(name)){
	return __modelFunctionDemand.at(name);
	}

	return decisionsEmpty;
	}

	const ScopeContextDecisions&
	ContextQuery::getStaticDecisions(const ScopePacked& scopeId){
	if (__modelStaticDecisions.count(scopeId)){
	return __modelStaticDecisions[scopeId];
	}

	return contextDecisionsEmpty;
	}

	void
	ContextQuery::prepareDemandModel(){
	const std::string& atomFunctionDemand = Config::get("clasp.bindings.function_demand");

	ClaspLayer::ModelFragment query = clasp->query(atomFunctionDemand);
	if (query)
	for (auto i = query->first; i!=query->second; ++i){
	string function;
	string decision;
	tie(function, decision) = ClaspLayer::parse<string, string>(i->second);

	FunctionContextDemand& decisions = __modelFunctionDemand[function];
	decisions.left.insert(make_pair(decisions.size(), decision));
	}
	}

	// const std::string& atomLateBinding = Config::get("clasp.bindings.function_uncertain");
	// query = clasp->query(atomLateBinding);
	//
	// std::map<std::string, std::vector<Expression>> dictFunctionDomain;
	// if (query){
	// for (auto i = query->first; i!=query->second; ++i){
	// string nameFunction;
	// Expression context;
	// tie(nameFunction, context) = ClaspLayer::parse<ScopePacked, Expression>(i->second);
	// dictFunctionDomain.at(nameFunction).push_back(context);
	// }
	//
	// for(auto& entry: dictFunctionDomain){
	// __modelFunctionDomain.emplace(entry.first, move(entry.second));
	// }
	// }

	} /* namespace xreate */

context.cppNo OneTemporaryActions

File Metadata

context.cppView Options

Event Timeline

context.cpp
No OneTemporary
Actions

context.cpp
View Options