---

InMemoryPool.cpp

#define TRACE_NAME "InMemoryPool"

#include "InMemoryPool.h"

//
//  Standard Member Functions
//

InMemoryPool::InMemoryPool(VariableScope* scope)
{
    if (scope) {
    this->scope = scope;
    scopeOwner = false;
    } else {
    this->scope = new SimpleVariableScope();
    scopeOwner = true;
    }
}

#if 0
// SHARE SCOPE -- a bit dangerous, but a lot easier
// -- no, don't do it until we copy the scope, too.
InMemoryPool::InMemoryPool(const InMemoryPool& other)
    : triples(other.triples),
      scope(other.scope),
      scopeOwner(false)
{ }
#endif 


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

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

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

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

size_t InMemoryPool::hash() const
{
    NOT_IMPLEMENTED
}

std::ostream& InMemoryPool::print_to(std::ostream& stream) const
{
    return TripleSource::print_to(stream);
}

#endif /* omit definitions until they are implemented */
    
InMemoryPool::~InMemoryPool()
{
    if (scopeOwner) delete scope;
}

//
//  Additional Public Member Functions
//


void InMemoryPool::add(Triple t)
{
    TRACE "Triple Added: " << t << "   ( size=" << triples.size() << " ) " << std::endl;
    TRACE "Hash is: " <<  t.hash() << std::endl;
    assert(getScope()->contains(t));
    triples.insert(t);
}

// The data part of the iterate, as a pointer to an iterator
#define PTR static_cast<std::hash_set<Triple>::iterator *>(ls.data.as_ptr)

static void reset_handler(LoopState& ls) 
{
    delete PTR;
    PTR = 0;
    ls.reset_handler = 0;
}

Triple InMemoryPool::fetch(Triple simplePattern, 
               LoopState& ls, 
               unsigned long max_results=0) const
{
    if (PTR == 0) {
    PTR = new std::hash_set<Triple>::iterator;
    *PTR = triples.begin();
    ls.reset_handler = reset_handler;
    } else {
    ++ *PTR;
    }
    if (*PTR == triples.end()) {
    delete PTR;
    PTR = 0;
    ls.reset_handler = 0;
    return Triple::null;
    }
    return * * PTR;
}

void InMemoryPool::remove(Triple t)
{
    triples.erase(t);
}

void InMemoryPool::replace(Symbol old, Symbol replacement)
{
    NOT_IMPLEMENTED;
}

void InMemoryPool::addAll(const TripleSource& source)
{
    LoopState ls;
    while(Triple t=source.fetch(Triple::null, ls)) {
    add(t);
    }
}

InMemoryPool::InMemoryPool(const TripleSource& other)
{
    this->scope = new SimpleVariableScope();
    scopeOwner = true;
    mUnion(other);
}

//
//  Additional Private Member Functions
//

#if 0
#include "UnitTest.h"
static bool test1(std::ostream& out) {
    return true;
}
static UnitTest t1(test1, __FILE__, 1, "");
#endif


#undef TRACE_NAME

---

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