int CStatsUtil::DoExportGameScripts()
{
//Validate output + input paths
Poco::Path inpath(m_inputPath);
Poco::Path outpath;
if( m_outputPath.empty() )
outpath = inpath.absolute().makeParent().append(DefExportScriptsDir);
else
outpath = Poco::Path(m_outputPath).makeAbsolute();
Poco::File fTestOut = outpath;
if( ! fTestOut.exists() )
{
cout << "Created output directory \"" << fTestOut.path() <<"\"!\n";
fTestOut.createDirectory();
}
else if( ! fTestOut.isDirectory() )
throw runtime_error("CStatsUtil::DoExportGameScripts(): Output path is not a directory!");
//Setup the script handler
GameScripts scripts( inpath.absolute().toString() );
//Convert to XML
scripts.ExportScriptsToXML( outpath.toString() );
return 0;
}
Solver::Solver(const Decomposition& decomposition, const Application& app, const std::vector<std::string>& encodingFiles, bool tableMode, bool cardinalityCost, bool printStatistics)
: ::Solver(decomposition, app)
, encodingFiles(encodingFiles)
, tableMode(tableMode)
, cardinalityCost(cardinalityCost)
, printStatistics(printStatistics)
{
Gringo::message_printer()->disable(Gringo::W_ATOM_UNDEFINED);
#ifndef DISABLE_CHECKS
// TODO: Implement tables::EncodingChecker
if(!tableMode) {
// Check the encoding, but only in the decomposition root.
// Otherwise we'd probably do checks redundantly.
if(decomposition.isRoot()) {
std::ofstream dummyStream;
std::unique_ptr<Gringo::Output::OutputBase> out(new Gringo::Output::OutputBase({}, dummyStream));
Gringo::Input::Program program;
asp_utils::DummyGringoModule module;
Gringo::Scripts scripts(module);
Gringo::Defines defs;
std::unique_ptr<EncodingChecker> encodingChecker{new trees::EncodingChecker(scripts, program, *out, defs)};
Gringo::Input::NonGroundParser parser(*encodingChecker);
for(const auto& file : encodingFiles)
parser.pushFile(std::string(file));
parser.parse();
encodingChecker->check();
}
}
#endif
}
/*
<% scripts(patterns); %>
Where patterns may contain *, ** and !pattern for exclusion
*/
PUBLIC void scripts(cchar *patterns)
{
HttpStream *stream;
HttpRx *rx;
HttpRoute *route;
EspRoute *eroute;
MprList *files;
MprJson *cscripts, *script;
cchar *uri, *path, *version;
int next, ci;
stream = getStream();
rx = stream->rx;
route = rx->route;
eroute = route->eroute;
patterns = httpExpandRouteVars(route, patterns);
if (!patterns || !*patterns) {
version = espGetConfig(route, "version", "1.0.0");
if (eroute->combineScript) {
scripts(eroute->combineScript);
} else if (espGetConfig(route, "http.content.combine[@=js]", 0)) {
if (espGetConfig(route, "http.content.minify[@=js]", 0)) {
eroute->combineScript = sfmt("all-%s.min.js", version);
} else {
eroute->combineScript = sfmt("all-%s.js", version);
}
scripts(eroute->combineScript);
} else {
if ((cscripts = mprGetJsonObj(route->config, "client.scripts")) != 0) {
for (ITERATE_JSON(cscripts, script, ci)) {
scripts(script->value);
}
}
}
return;
}
vector < ustring > scripts_get_all()
// Gets a list of available scripts.
{
// Read available scripts and clean them up.
ReadFiles rf(Directories->get_scripts(), script_prefix(stEnd), "");
for (unsigned int i = 0; i < rf.files.size(); i++) {
for (int scripttype = stSed; scripttype < stEnd; scripttype++) {
ustring prefix = script_prefix((ScriptType) scripttype);
ustring source_suffix = script_suffix((ScriptType) scripttype, false);
ustring binary_suffix = script_suffix((ScriptType) scripttype, true);
if (g_str_has_prefix(rf.files[i].c_str(), prefix.c_str())) {
rf.files[i].erase(0, prefix.length());
}
if (!source_suffix.empty()) {
if (g_str_has_suffix(rf.files[i].c_str(), source_suffix.c_str())) {
rf.files[i].erase(rf.files[i].length() - source_suffix.length(), source_suffix.length());
}
}
if (!binary_suffix.empty()) {
if (g_str_has_suffix(rf.files[i].c_str(), binary_suffix.c_str())) {
rf.files[i].erase(rf.files[i].length() - binary_suffix.length(), binary_suffix.length());
}
}
}
}
// In cases of TECkit, there is the .map script and the compiled .tec script.
// These both have the same name, so we have two scripts of the same name.
// Remove any double names.
set < ustring > scriptset(rf.files.begin(), rf.files.end());
vector < ustring > scripts(scriptset.begin(), scriptset.end());
// Sort them.
sort(scripts.begin(), scripts.end());
// Add the "straight through" script at the start.
scripts.insert(scripts.begin(), scripts_straight_through());
// Return them.
return scripts;
}
int CStatsUtil::DoImportGameScripts()
{
//Validate output + input paths
Poco::Path inpath(m_inputPath);
Poco::Path outpath;
if( m_outputPath.empty() )
throw runtime_error("CStatsUtil::DoImportGameScripts() : Output path is empty!");
if( !utils::isFolder( m_outputPath ) )
throw runtime_error("CStatsUtil::DoImportGameScripts() : Output path doesn't exist, or isn't a directory!");
outpath = Poco::Path(m_outputPath);
//Setup the script handler
GameScripts scripts( outpath.absolute().toString() );
//Import from XML
scripts.ImportScriptsFromXML( inpath.absolute().toString() );
return 0;
}
Solver::Solver(const Decomposition& decomposition, const Application& app, const std::vector<std::string>& encodingFiles, bool reground, BranchAndBoundLevel bbLevel)
: ::LazySolver(decomposition, app, bbLevel)
, reground(reground)
, encodingFiles(encodingFiles)
{
Gringo::message_printer()->disable(Gringo::W_ATOM_UNDEFINED);
if(!reground) {
// Set up ASP solver
config.solve.numModels = 0;
Clasp::Asp::LogicProgram& claspProgramBuilder = static_cast<Clasp::Asp::LogicProgram&>(clasp.startAsp(config, true)); // TODO In leaves updates might not be necessary.
struct LazyGringoOutputProcessor : GringoOutputProcessor
{
LazyGringoOutputProcessor(Solver* s, Clasp::Asp::LogicProgram& prg)
: GringoOutputProcessor(prg), self(s)
{
}
void storeAtom(unsigned int atomUid, Gringo::Value v) override
{
const std::string& n = *v.name();
if(n == "childItem") {
ASP_CHECK(v.args().size() == 1, "'childItem' predicate does not have arity 1");
std::ostringstream argument;
v.args().front().print(argument);
self->itemsToLitIndices.emplace(String(argument.str()), self->literals.size());
self->literals.push_back(Clasp::posLit(atomUid));
}
else if(n == "childAuxItem") {
ASP_CHECK(v.args().size() == 1, "'childAuxItem' predicate does not have arity 1");
std::ostringstream argument;
v.args().front().print(argument);
self->auxItemsToLitIndices.emplace(String(argument.str()), self->literals.size());
self->literals.push_back(Clasp::posLit(atomUid));
}
GringoOutputProcessor::storeAtom(atomUid, v);
}
Solver* self;
} gringoOutput(this, claspProgramBuilder);
std::unique_ptr<Gringo::Output::OutputBase> out(new Gringo::Output::OutputBase({}, gringoOutput));
Gringo::Input::Program program;
asp_utils::DummyGringoModule module;
Gringo::Scripts scripts(module);
Gringo::Defines defs;
Gringo::Input::NongroundProgramBuilder gringoProgramBuilder(scripts, program, *out, defs);
Gringo::Input::NonGroundParser parser(gringoProgramBuilder);
// Input: Induced subinstance
std::unique_ptr<std::stringstream> instanceInput(new std::stringstream);
asp_utils::induceSubinstance(*instanceInput, app.getInstance(), decomposition.getNode().getBag());
app.getPrinter().solverInvocationInput(decomposition, instanceInput->str());
// Input: Decomposition
std::unique_ptr<std::stringstream> decompositionInput(new std::stringstream);
asp_utils::declareDecomposition(decomposition, *decompositionInput);
app.getPrinter().solverInvocationInput(decomposition, decompositionInput->str());
// Pass input to ASP solver
for(const auto& file : encodingFiles)
parser.pushFile(std::string(file));
parser.pushStream("<instance>", std::move(instanceInput));
parser.pushStream("<decomposition>", std::move(decompositionInput));
parser.parse();
// Ground
program.rewrite(defs);
program.check();
if(Gringo::message_printer()->hasError())
throw std::runtime_error("Grounding stopped because of errors");
auto gPrg = program.toGround(out->domains);
Gringo::Ground::Parameters params;
params.add("base", {});
gPrg.ground(params, scripts, *out);
params.clear();
// Set value of external atoms to free
for(const auto& p : literals)
claspProgramBuilder.freeze(p.var(), Clasp::value_free);
// Finalize ground program and create solver literals
claspProgramBuilder.endProgram();
// Map externals to their solver literals
for(auto& p : literals) {
p = claspProgramBuilder.getLiteral(p.var());
assert(!p.watched()); // Literal must not be watched
}
for(const auto& atom : gringoOutput.getItemAtomInfos())
itemAtomInfos.emplace_back(ItemAtomInfo(atom, claspProgramBuilder));
for(const auto& atom : gringoOutput.getAuxItemAtomInfos())
auxItemAtomInfos.emplace_back(AuxItemAtomInfo(atom, claspProgramBuilder));
// for(const auto& atom : gringoOutput->getCurrentCostAtomInfos())
// currentCostAtomInfos.emplace_back(CurrentCostAtomInfo(atom, claspProgramBuilder));
// for(const auto& atom : gringoOutput->getCostAtomInfos())
// costAtomInfos.emplace_back(CostAtomInfo(atom, claspProgramBuilder)));
// Prepare for solving.
clasp.prepare();
}
}
void Solver::startSolvingForCurrentRowCombination()
{
// ++solverSetups;
asyncResult.reset();
if(reground) {
// Set up ASP solver
config.solve.numModels = 0;
// TODO The last parameter of clasp.startAsp in the next line is "allowUpdate". Does setting it to false have benefits?
// WORKAROUND for BUG in ClaspFacade::startAsp()
// TODO remove on update to new version
if(clasp.ctx.numVars() == 0 && clasp.ctx.frozen())
clasp.ctx.reset();
Clasp::Asp::LogicProgram& claspProgramBuilder = static_cast<Clasp::Asp::LogicProgram&>(clasp.startAsp(config));
GringoOutputProcessor gringoOutput(claspProgramBuilder);
std::unique_ptr<Gringo::Output::OutputBase> out(new Gringo::Output::OutputBase({}, gringoOutput));
Gringo::Input::Program program;
asp_utils::DummyGringoModule module;
Gringo::Scripts scripts(module);
Gringo::Defines defs;
Gringo::Input::NongroundProgramBuilder gringoProgramBuilder(scripts, program, *out, defs);
Gringo::Input::NonGroundParser parser(gringoProgramBuilder);
// Input: Induced subinstance
std::unique_ptr<std::stringstream> instanceInput(new std::stringstream);
asp_utils::induceSubinstance(*instanceInput, app.getInstance(), decomposition.getNode().getBag());
app.getPrinter().solverInvocationInput(decomposition, instanceInput->str());
// Input: Decomposition
std::unique_ptr<std::stringstream> decompositionInput(new std::stringstream);
asp_utils::declareDecomposition(decomposition, *decompositionInput);
app.getPrinter().solverInvocationInput(decomposition, decompositionInput->str());
// Input: Child rows
std::unique_ptr<std::stringstream> childRowsInput(new std::stringstream);
*childRowsInput << "% Child row facts" << std::endl;
for(const auto& row : getCurrentRowCombination()) {
for(const auto& item : row->getItems())
*childRowsInput << "childItem(" << item << ")." << std::endl;
for(const auto& item : row->getAuxItems())
*childRowsInput << "childAuxItem(" << item << ")." << std::endl;
// TODO costs, etc.
}
app.getPrinter().solverInvocationInput(decomposition, childRowsInput->str());
// Pass input to ASP solver
for(const auto& file : encodingFiles)
parser.pushFile(std::string(file));
parser.pushStream("<instance>", std::move(instanceInput));
parser.pushStream("<decomposition>", std::move(decompositionInput));
parser.pushStream("<child_rows>", std::move(childRowsInput));
parser.parse();
// Ground
program.rewrite(defs);
program.check();
if(Gringo::message_printer()->hasError())
throw std::runtime_error("Grounding stopped because of errors");
auto gPrg = program.toGround(out->domains);
Gringo::Ground::Parameters params;
params.add("base", {});
gPrg.ground(params, scripts, *out);
params.clear();
claspProgramBuilder.endProgram();
itemAtomInfos.clear();
for(const auto& atom : gringoOutput.getItemAtomInfos())
itemAtomInfos.emplace_back(ItemAtomInfo(atom, claspProgramBuilder));
auxItemAtomInfos.clear();
for(const auto& atom : gringoOutput.getAuxItemAtomInfos())
auxItemAtomInfos.emplace_back(AuxItemAtomInfo(atom, claspProgramBuilder));
// TODO costs etc.
clasp.prepare();
}
else {
// Set external variables to the values of the current child row combination
clasp.update(false, false);
clasp.prepare();
// Mark atoms corresponding to items from the currently extended rows
for(const auto& row : getCurrentRowCombination()) {
for(const auto& item : row->getItems()) {
assert(itemsToLitIndices.find(item) != itemsToLitIndices.end());
assert(itemsToLitIndices.at(item) < literals.size());
#ifdef DISABLE_CHECKS
literals[itemsToLitIndices.at(item)].watch();
#else
try {
literals[itemsToLitIndices.at(item)].watch();
}
catch(const std::out_of_range&) {
std::ostringstream msg;
msg << "Unknown variable; atom childItem(" << *item << ") not shown or not declared as external?";
throw std::runtime_error(msg.str());
}
#endif
}
for(const auto& item : row->getAuxItems()) {
assert(auxItemsToLitIndices.find(item) != auxItemsToLitIndices.end());
assert(auxItemsToLitIndices.at(item) < literals.size());
#ifdef DISABLE_CHECKS
literals[auxItemsToLitIndices.at(item)].watch();
#else
try {
literals[auxItemsToLitIndices.at(item)].watch();
}
catch(const std::out_of_range&) {
std::ostringstream msg;
msg << "Unknown variable; atom childAuxItem(" << *item << ") not shown or not declared as external?";
throw std::runtime_error(msg.str());
}
#endif
}
}
// Set marked literals to true and all others to false
for(auto& lit : literals) {
if(lit.watched()) {
lit.clearWatch();
clasp.assume(lit);
}
else
clasp.assume(~lit);
}
}
asyncResult.reset(new BasicSolveIter(clasp));
}
bool QtWebEnginePage::acceptNavigationRequest(const QUrl &url, QWebEnginePage::NavigationType type, bool isMainFrame)
{
if (m_isPopup)
{
emit aboutToNavigate(url, type);
return false;
}
if (isMainFrame && url.scheme() == QLatin1String("javascript"))
{
runJavaScript(url.path());
return false;
}
if (url.scheme() == QLatin1String("mailto"))
{
QDesktopServices::openUrl(url);
return false;
}
if (isMainFrame && type == QWebEnginePage::NavigationTypeReload && m_previousNavigationType == QWebEnginePage::NavigationTypeFormSubmitted && SettingsManager::getValue(QLatin1String("Choices/WarnFormResend")).toBool())
{
bool cancel(false);
bool warn(true);
if (m_widget)
{
ContentsDialog dialog(ThemesManager::getIcon(QLatin1String("dialog-warning")), tr("Question"), tr("Are you sure that you want to send form data again?"), tr("Do you want to resend data?"), (QDialogButtonBox::Yes | QDialogButtonBox::Cancel), NULL, m_widget);
dialog.setCheckBox(tr("Do not show this message again"), false);
connect(m_widget, SIGNAL(aboutToReload()), &dialog, SLOT(close()));
m_widget->showDialog(&dialog);
cancel = !dialog.isAccepted();
warn = !dialog.getCheckBoxState();
}
else
{
QMessageBox dialog;
dialog.setWindowTitle(tr("Question"));
dialog.setText(tr("Are you sure that you want to send form data again?"));
dialog.setInformativeText(tr("Do you want to resend data?"));
dialog.setIcon(QMessageBox::Question);
dialog.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
dialog.setDefaultButton(QMessageBox::Cancel);
dialog.setCheckBox(new QCheckBox(tr("Do not show this message again")));
cancel = (dialog.exec() == QMessageBox::Cancel);
warn = !dialog.checkBox()->isChecked();
}
SettingsManager::setValue(QLatin1String("Choices/WarnFormResend"), warn);
if (cancel)
{
return false;
}
}
if (isMainFrame && type != QWebEnginePage::NavigationTypeReload)
{
m_previousNavigationType = type;
}
if (isMainFrame)
{
scripts().clear();
const QList<UserScript*> scripts(AddonsManager::getUserScriptsForUrl(url));
for (int i = 0; i < scripts.count(); ++i)
{
QWebEngineScript::InjectionPoint injectionPoint(QWebEngineScript::DocumentReady);
if (scripts.at(i)->getInjectionTime() == UserScript::DocumentCreationTime)
{
injectionPoint = QWebEngineScript::DocumentCreation;
}
else if (scripts.at(i)->getInjectionTime() == UserScript::DeferredTime)
{
injectionPoint = QWebEngineScript::Deferred;
}
QWebEngineScript script;
script.setSourceCode(scripts.at(i)->getSource());
script.setRunsOnSubFrames(scripts.at(i)->shouldRunOnSubFrames());
script.setInjectionPoint(injectionPoint);
this->scripts().insert(script);
}
emit aboutToNavigate(url, type);
}
return true;
}
ItemTreePtr Solver::compute()
{
const auto nodeStackElement = app.getPrinter().visitNode(decomposition);
// Compute item trees of child nodes
ChildItemTrees childItemTrees;
for(const auto& child : decomposition.getChildren()) {
ItemTreePtr itree = child->getSolver().compute();
if(!itree)
return itree;
childItemTrees.emplace(child->getNode().getGlobalId(), std::move(itree));
}
// Input: Child item trees
std::unique_ptr<std::stringstream> childItemTreesInput(new std::stringstream);
*childItemTreesInput << "% Child item tree facts" << std::endl;
for(const auto& childItemTree : childItemTrees) {
std::ostringstream rootItemSetName;
rootItemSetName << 'n' << childItemTree.first;
asp_utils::declareItemTree(*childItemTreesInput, childItemTree.second.get(), tableMode, childItemTree.first, rootItemSetName.str());
}
app.getPrinter().solverInvocationInput(decomposition, childItemTreesInput->str());
// Input: Induced subinstance
std::unique_ptr<std::stringstream> instanceInput(new std::stringstream);
asp_utils::induceSubinstance(*instanceInput, app.getInstance(), decomposition.getNode().getBag());
app.getPrinter().solverInvocationInput(decomposition, instanceInput->str());
// Input: Decomposition
std::unique_ptr<std::stringstream> decompositionInput(new std::stringstream);
asp_utils::declareDecomposition(decomposition, *decompositionInput);
app.getPrinter().solverInvocationInput(decomposition, decompositionInput->str());
// Set up ASP solver
Clasp::ClaspConfig config;
config.solve.numModels = 0;
Clasp::ClaspFacade clasp;
// TODO The last parameter of clasp.startAsp in the next line is "allowUpdate". Does setting it to false have benefits?
Clasp::Asp::LogicProgram& claspProgramBuilder = dynamic_cast<Clasp::Asp::LogicProgram&>(clasp.startAsp(config));
std::unique_ptr<Gringo::Output::LparseOutputter> lpOut(newGringoOutputProcessor(claspProgramBuilder, childItemTrees, tableMode));
std::unique_ptr<Gringo::Output::OutputBase> out(new Gringo::Output::OutputBase({}, *lpOut));
Gringo::Input::Program program;
asp_utils::DummyGringoModule module;
Gringo::Scripts scripts(module);
Gringo::Defines defs;
Gringo::Input::NongroundProgramBuilder gringoProgramBuilder(scripts, program, *out, defs);
Gringo::Input::NonGroundParser parser(gringoProgramBuilder);
// Pass input to ASP solver
for(const auto& file : encodingFiles)
parser.pushFile(std::string(file));
parser.pushStream("<instance>", std::move(instanceInput));
parser.pushStream("<decomposition>", std::move(decompositionInput));
parser.pushStream("<child_itrees>", std::move(childItemTreesInput));
parser.parse();
// Ground and solve
program.rewrite(defs);
program.check();
if(Gringo::message_printer()->hasError())
throw std::runtime_error("Grounding stopped because of errors");
auto gPrg = program.toGround(out->domains);
Gringo::Ground::Parameters params;
params.add("base", {});
gPrg.ground(params, scripts, *out);
params.clear();
// Finalize ground program and create solver variables
claspProgramBuilder.endProgram();
std::unique_ptr<asp_utils::ClaspCallback> cb(newClaspCallback(tableMode, *lpOut, childItemTrees, app, decomposition.isRoot(), decomposition, cardinalityCost));
cb->prepare(claspProgramBuilder);
clasp.prepare();
clasp.solve(cb.get());
if(printStatistics) {
std::cout << "Solver statistics for decomposition node " << decomposition.getNode().getGlobalId() << ':' << std::endl;
Clasp::Cli::TextOutput{true, Clasp::Cli::TextOutput::format_asp}.printStatistics(clasp.summary(), true);
}
ItemTreePtr result = cb->finalize(decomposition.isRoot(), app.isPruningDisabled() == false || decomposition.isRoot());
app.getPrinter().solverInvocationResult(decomposition, result.get());
return result;
}
