---

QueryablePool.cpp

#define TRACE_NAME "QueryablePool"
#include "QueryablePool.h"
// $Id: QueryablePool_8cpp-source.html,v 1.2 2001/10/10 20:40:58 sandro Exp $
#include "InMemoryPool.h"
#include "Query.h"

//
//  Standard Member Functions
//

QueryablePool::QueryablePool()
{
    // blank default    
}

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

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

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

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

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

size_t QueryablePool::hash() const
{
    NOT_IMPLEMENTED
}

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

#endif /* omit definitions until they are implemented */
    
QueryablePool::~QueryablePool()
{
    // blank default    
}

//
//  Additional Public Member Functions
//



TripleSource* QueryablePool::unionWith(const TripleSource& other) 
{
    // really just a namespace thing...
    NOT_IMPLEMENTED;
}

/* this implementation is NOT XSB specific, just QueryablePool... */

TripleSource* QueryablePool::intersect(const TripleSource& other, int max) 
{

    // BUG   max isn't really implemented here, with this cheezy algorithm.

    InMemoryPool* newPat = new InMemoryPool(other);
    TRACE "Intersect Me  " << *this << endl;
    TRACE "and newPat" << *newPat << endl;

    while (true) {

        if (newPat->size() == 0) return newPat;

        Query* m = query(*newPat);
        if (m->fetch()) {
            // in theory we have information here which could be useful,
            delete m;
        TRACE "returning newpat = " << newPat << endl;
            return newPat;
        }

    Triple t = m->getFailurePoint();
        delete m;
        newPat->remove(t);
    TRACE "newPat losing triple: " << t << endl;
    }
}

TripleSource* QueryablePool::diff(const TripleSource& other, int max) 
{
    // do we need Foreign  for this?   t comes from other
    // and gets added to diff....
    InMemoryPool newPat(other.getScope());
    //newPat.addAll(other);
    newPat.mUnion(other);
    InMemoryPool* diff = new InMemoryPool(other.getScope());
    int diffsFound = 0;

    while (diffsFound <= max) {

        if (newPat.size() == 0) return diff;

        Query* m = this->query(newPat);
        if (m->fetch()) {
            // in theory we have information here which could be useful,
            // like for the other half of the match process.
            delete m;
            return diff;
        }

        Triple t = m->getFailurePoint();
        delete m;

        diff->add(t);
        newPat.remove(t);
        ++diffsFound;
    }
    return diff;

}


//
//  Additional Private Member Functions
//

#undef TRACE_NAME

---

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