---

XSBQuery.cpp

#define TRACE_NAME "XSBQuery"

#include "XSBQuery.h"
// $Id: XSBQuery_8cpp-source.html,v 1.2 2001/10/10 20:40:58 sandro Exp $
#include "XSBAgent.h"
#include "FlowManager.h"
#include "XSBPool.h"

//
//  Standard Member Functions
//

XSBQuery::XSBQuery(XSBAgent& agent, const XSBPool& dataset, 
           const TripleSource& pattern)
    : Query(pattern),
      pattern(pattern),
      dataset(dataset),
      agent(agent),
      open(true),
      running(false),
      varsMatchOnlyVars(true)
{
    assert(agent.currentQuery == 0);
    agent.currentQuery = this;
    file = agent.getFile(&fileName);
    runPredicate = agent.getNewPredicate();
}

#if 0  /* omit definitions until they are implemented */

XSBQuery::XSBQuery(const XSBQuery& other)
{
    NOT_IMPLEMENTED
}

const XSBQuery& XSBQuery::operator=(const XSBQuery& other)
{
    NOT_IMPLEMENTED
}

bool XSBQuery::operator==(const XSBQuery& other) const
{
    NOT_IMPLEMENTED
}

bool XSBQuery::operator<(const XSBQuery& other) const
{
    NOT_IMPLEMENTED
}

size_t XSBQuery::hash() const
{
    NOT_IMPLEMENTED
}

std::ostream& XSBQuery::print_to(std::ostream& stream) const
{
    NOT_IMPLEMENTED
}

#endif /* omit definitions until they are implemented */
    
XSBQuery::~XSBQuery()
{
    close();
}

//
//  Additional Public Member Functions
//

void XSBQuery::close()
{
    if (open) {
    if (running) *(agent.out) << "done.\n";
    agent.currentQuery = 0;
    open = false;
    }
}

Triple XSBQuery::getFailurePoint()
{
    return failurePoint;
}

bool XSBQuery::advanceToFirst() 
{
    running = true;
    agent.sync();
    TRACE "** Sync'd" << endl;
    writeFile();
    TRACE "** Written" << endl;
    *(agent.out) << "['" << fileName << "'].\n";
    readIndex = 0;
    state = SEARCHING;
    *(agent.out) << runPredicate << ".\n";
    return true;
}

bool XSBQuery::advanceToNext() 
{
    *(agent.out) << "more.\n";
    return true;
}

bool XSBQuery::getResults() 
{ 
    state = SEARCHING;
    FlowManager::main.run();
    TRACE "returned from run(), state=" << state << endl;

    // ...?   stuff with .bindings?
    if (!moreResultsPossible) running = false;
    return moreResultsPossible;
    
}


//
//  Additional Private Member Functions
//

void XSBQuery::printTriple(std::ostream& out, Triple t, int* maxVar) 
{
    for (int i=0; i<3; i++) {
    Symbol s = t.get(i);
    if (s.isVar()) {
        int index = s.index();
        if (varsMatchOnlyVars) out << "var(";
        out << "V" << index;
        if (maxVar && index > *maxVar) *maxVar = index;
        if (varsMatchOnlyVars) out << ")";
    } else {
        out << s.index();
    }
    if (i<2) out << ",";
    }
}

void XSBQuery::writeFile()
{
    *file << "% This is prolog file written by Blindfold::XSBQuery.\n\n";


    // write the dataset
    /*
      Theory Break...

      I think we need to keep the variables in the dataset as real variables!
      
      But then how can we get their values?  I don't really know how.

      But we could get triple-id-->triple-id matching, I suppose which
      would do most of the work for us.  And if we had a match, we
      could ask what was left over, too.

    */

    LoopState l;
    // write the pattern rule
    *file << runPredicate << " :- (\n";
    // first, the main pattern body
    size_t pcount=0;
    maxVar=-1;
    while (Triple t = pattern.fetch(Triple::null, l)) {
    pv.push_back(t);
    *file << "set_status(" << pcount << "), ";
    *file << dataset.predicate << "(";
    printTriple(*file, t, &maxVar);
    // *file << ",T" << pcount << "),\n";
    *file << "),\n";
    pcount++;
    }
    // then flag success & print the variable's values
    *file << "put(1), writeln(" << MATCH_FOLLOWS << "),\n";
    size_t position = 0;
    for (int i=0; i<=maxVar; i++) {
    *file << "writeln(V" << i  << "),\n";
    // TRACE "pos[" << position << "] = variable:" << pattern->getScope()->getVar(i) << std::endl;
    position++;
    }
#if 0       // we're not doing triple-numbers at the moment -- no need
    for (unsigned int i=0; i<pcount; i++) {
    *file << "writeln(T" << i  << "),\n";
    // TRACE "pos[" << position << "] = triple: " << dv[i] << std::endl;
    position++;
    }
#endif
    *file << "put(4),\n";

    // then prompt for continue or not
    *file << "read(DoneFlag), DoneFlag=done\n";

    // then give an alternative (for failure) to signal completion
    *file << "); put(1), writeln(" << FAILPOINT_FOLLOWS << 
    "), get_status(Status), writeln(Status), put(4), put(10).\n\n";


    file->flush();
    TRACE "Wrote file " << fileName << std::endl;

}

void XSBQuery::handleValue(int value)
{
    TRACE "    state=" << state << ", value=" << value << ".   ";
    Triple pt;
    switch (state) {
    case SEARCHING:
    switch (value) {
    case MATCH_FOLLOWS:
        state = READING_MATCH;
        success = true;
        TRACE "match follows!";
        break;
    case FAILPOINT_FOLLOWS:
        state = READING_FAILURE;
        TRACE "failure follows!";
        success = false;
        break;
    default:
        throw(new std::string("huh"));
    }
    break;
    case READING_MATCH:
    if (readIndex <= maxVar) {
        Symbol v = pattern.getScope()->getVar(readIndex);
        TRACE "read pos[" << readIndex << "] = variable:" << v;
        if (value == -1) {
        TRACE " *unbound*" << std::endl;
        } else {
        Symbol b = Symbol(&Symbol::global, value);
        v.bind(b);
        TRACE " bind(" << b << ")" << std::endl;
        }
    } else {
        state = EXPECTING_END;
#if 0
        int pos = (readIndex - maxVar) - 1;
        //Triple dt = dv[pos];
        Triple pt = pv[value];
        //TRACE "read pos=" << pos << ", " << dt << " == " << pt << std::endl;

            // set the variables

            // remove this one from some set to find out what's
            // remaining.
#endif
    }
    readIndex++;
    break;
    case READING_FAILURE:
    pt = pv[value];
    TRACE "\n\n############\n\nfailed on " << value << ", t=" << pt << std::endl;
    TRACE "NOT IN " << dataset << "\n\n";
    failurePoint = pt;
    moreResultsPossible = false;
    state = EXPECTING_END;
    break;
    case EXPECTING_END:
    if (value == -1) {
        FlowManager::main.returnFromRun();
        TRACE "\nQuery fetch is done!" << endl;
        state = ENDED;
        return;
    } else  {
        TRACE "XSB protocol error: didn't get end when expecting it!" << endl;
    }
    break;
    case ENDED:
    assert(false);
    break;
    }
    TRACE std::endl;
}

#undef TRACE_NAME

---

Home to blindfold. This page generated via doxygen 1.2.11.1 Wed Oct 10 16:40:33 2001.