---

TripleSink.cpp

#define TRACE_NAME "TripleSink"

#include "TripleSink.h"
#include "TripleSource.h"
#include <string>
#include <stdio.h>
#include "ForeignVariableScope.h"
#include "LoopState.h"

//
//  Standard Member Functions
//

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

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

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

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

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

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

size_t TripleSink::hash() const
{
    NOT_IMPLEMENTED
}

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

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

//
//  Additional Public Member Functions
//

VariableScope* TripleSink::getScope() const
{
    NOT_IMPLEMENTED;
}


#if 0
Symbol symbolFor(std::string text, TripleSink* sink)
{
    return symbolFor(text.c_str(), sink);
}

Symbol symbolFor(char *text, TripleSink* sink)
{
    return symbolFor(text, 0, sink);
}

Symbol symbolFor(char *text, char *early_end, TripleSink* sink)
{
    /*
      There are all sorts of clever tricks we could do.

      We're not doing them at the moment.
    */
    std::string buf("data:,");
    char c[4];
    for (char* p=text; *p && p!=early_end; p++) {
    if (isalnum(*p)) {
        buf.append(p, 1);
    } else {
        sprintf(c, "%%%02x", *p);
        buf.append(c, 3);
    }
    }
    return Symbol(sink->getSpace(), buf.c_str());
}

static int count=0;
Symbol symbolForAnonymous(char *text, TripleSink* sink)
{
    return symbolForAnonymous(text, sink->getSpace());
}
Symbol symbolForAnonymous(char *text, SymbolSpace* space)
{
    static char b1[16];
    sprintf(b1, "_:%d_", count++);
    std::string b2(b1);
    b2.append(text);
    
    return Symbol(space, b2.c_str());
}
#endif

#if 0
void addForeign(const TripleSource& source)
{
     SymbolMap m;
        LoopState l;
        for (Triple t = tmp.fetch(Triple::NULL, l)) {
        for (size_t i=0; i<3; i++) {
            Symbol s = t.get(i);
            if (s.isVar()) {
            // remap s
            t.put(s);
            }
        }
        pool.add(t);
        }

}
#endif


void TripleSink::mUnion(const TripleSource& source)
{
    LoopState ls;

    if (source.getScope() == getScope()) {
    TRACE "degenerate mUnion stays in same scope!   yay!" << endl;
    while(Triple t=source.fetch(Triple::null, ls)) {
        add(t);
    }
    return;
    }

    size_t numVars = source.getScope()->getNumVars();
    std::vector<Symbol> map(numVars);

    TRACE "Mapping variables from " << *source.getScope() << " ==> " <<
    *getScope() << endl;
    for (size_t i=0; i<numVars; i++) {
    Symbol external = source.getScope()->getVar(i);
    TRACE " var # " << i << ":  " << external;
    int count=2;
    std::string s(external.text());
    std::string n(s);
    while (true) {
        bool added = false;
        Symbol internal = getScope()->getVar(n.c_str(), &added);
        if (added) {
        TRACE " ==> new " << internal << endl;
        map[i] = internal;
        break;
        } 
        TRACE "*collision* as " << n << ", ";

        char buf[20];
        sprintf(buf, "_%d", count++);
        n=s+buf;
        TRACE "trying as " << n << endl;
    }
    }

    while(Triple t=source.fetch(Triple::null, ls)) {
    for (int i=0; i<3; i++) {
        if (t.get(i).isVar()) {
        t.set(i, map[t.get(i).index()]);
        }
    }
    TRACE "mUnion adding: " << t << endl;
        add(t);
    }
}

//
//  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.