---

main.cpp

static char const 
            cvsid[] = "$Id: main_8cpp-source.html,v 1.11 2001/10/10 20:40:59 sandro Exp $";
#define VERSION "Blindfold Version 0.1.1 (main $Revision: 1.11 $ $Date: 2001/10/10 20:40:59 $)"
#define TRACE_NAME "main"

#include <getopt.h>
#include <sstream>
#include <cstdio>

#include "Parser.h"
#include "GrammarManager.h"
#include "TripleSink.h"
#include "LoggingTripleSink.h"
#include "XSBAgent.h"
#include "InMemoryPool.h"
#include "Query.h"
#include "XSBQuery.h"
#include "XSBPool.h"
#include "NTriplesParser.h"
#include "NTriplesGenerator.h"
#include "FlowManager.h"
#include "ForeignVariableScope.h"
#include "Trace.h"
#include "Rule.h"

char* programName;
bool gotCommand = false;
std::string command;

void help() {
    std::ostream& o = std::cerr;

    if (gotCommand) {
    if (command == "conjoin") {
        o << "The conjoin operation returns all triples in any of the input datasets, modifying\nthe names of existential variables so they do not collide." << endl;
    } else {
        o << "No documentation for \"" << command << "\"" << endl;
    }
    return;
    }

    o << 
//       ********************************************************************************   <== 80 chars
    "\nusage: " << programName << " [general options] command [dataset...]\n"
    "\n"
    "GENERAL OPTIONS:\n"
    " -?  --help [command]        Give this help message, or help on the command\n";
    if (DO_TRACE) {
    o << " -t  --trace module-name     Turn tracing on for named module\n";
    } else {
    o << "(-t  --trace module-name)   (Tracing turned off at compile-time)\n";
    }
    o <<
//  " -o  --output filename       Direct output to the named file\n"
    " -v  --version               Report software version\n"
    "\n"
    "COMMANDS:\n"
    " report         Report number of triples in conjoin, common, posdiff, negdiff\n" 
    " conjoin        Combine the datasets, keeping bNodes distincts\n" 
    " common         Find the greatest common subgraph of two datasets\n" 
    " diff           Give posdiff & negdiff, unix style\n"
    " posdiff        What would you need to add to dataset B to equal dataset A?\n"
    " negdiff        What would you need to add to dataset A to equal dataset B?\n"
    "\n"
    "DATASET SYNTAXES:\n"
    " default             N-Triples file name, relative to current directory\n"
    "\n"
    "For more information see http://www.w3.org/2001/06/blindfold\n\n";
}

// should be wrapped into Pool::open, I think...
static void loadFile(Pool& pool, const char* filename) 
{
    NTriplesParser parser;
    // this is really only necessary if the pool is not empty
    ForeignVariableScope tmp(pool.getScope());
    parser.setSink(&pool, &tmp);
    FlowManager::main.streamIn(filename, parser, true);
    FlowManager::main.run();

    // std::cout << "\n# Read triples from \"" << filename << "\"\n" << pool;
}

static Pool* compare(Agent& agent, 
                 TripleSource *lefts, TripleSource *rights, 
                 bool intersect, int max)
{
    TripleSource* result = 0;
    SimpleVariableScope leftScope;
    SimpleVariableScope rightScope;
    
    QueryablePool* left = agent.newQueryablePool(&leftScope);
    QueryablePool* right = agent.newQueryablePool(&rightScope);
    
    left->mUnion(*lefts);    
    right->mUnion(*rights);
    
    //TRACE "compare left BEFORE: " << *lefts << endl;
    TRACE "compare left: " << *left << endl;
    //TRACE "compare right BEFORE: " << *rights << endl;
    TRACE "compare right: " << *right << endl;

    if (intersect) {
    result = left->intersect(*right, max);
    } else {
    result = left->diff(*right, max);
    }
    
    TRACE "compare RESULT: " << *result << endl;

    // get into a new scope to return...
    InMemoryPool* returnable = new InMemoryPool(*result);

    delete left;
    delete right;

    return returnable;
}

int main(int argc, char** argv) 
{
    programName = argv[0];
    bool wantsHelp = false;
    int c;
    int option_index = 0;
    std::vector<TripleSource*> sources;
    int max=0x7fffffff;
    static struct option long_options[] =
    {
    {"help", 0, 0, '?'},
    {"trace", 1, 0, 't'},
    {"output", 1, 0, 'o'},
    {"max", 1, 0, 'm'},
    {"version", 0, 0, 'v'},
    {"rule", 0, 0, 'r'},
    {"universal-variable-pattern", 1, 0, 'u'},
    {0, 0, 0, 0}
    };
    static char* short_options = 
    "-"   // gnu specific (?) flag to allow intermixing files & options
    "t:"
    "o:"
    "m:"
    "v"
    "r" // hacked to take TWO parameters
    "u:"
    "?";
    char *varPattern = ".*#(_|[A-Z]).*";
    std::vector<Rule*> rules;
    int gettingRule = 0;
    const TripleSource* rulePremise;

    while (1) {

    c = getopt_long(argc, argv, short_options, long_options, 0);

    if (c == -1) break;

    switch (c) {

    case 1:
        if (gotCommand || gettingRule) {
        Pool* s = new InMemoryPool();
        loadFile(*s, optarg);       
        TRACE "Loaded pool from " << optarg << *s << endl;
        if (gettingRule == 2) {
            TRACE "... and saved it as rule premise" << endl;
            rulePremise = s;
            gettingRule--;
        } else if (gettingRule == 1) {
            TRACE "... and using it as rule conclusion" << endl;
            rules.push_back(new Rule(*rulePremise, *s, varPattern));
            delete rulePremise;
            delete s;
            gettingRule--;
        } else {
            TRACE "... and saved it as source #" << sources.size() << endl;
            sources.push_back(s);
        }
        } else {
        command = optarg;
        gotCommand = true;
        }
        break;

    case 'r': 
        gettingRule = 2;
        break;
        
    case 'u':
        varPattern = optarg;    // we don't need strdup, do we?
        break;
    
    case 't':
        Trace::set(optarg, true);
        break;

    case 'm':
        max = atoi(optarg);
        break;

    case 'o':
        NOT_IMPLEMENTED;

    case 'v':
        std::cout << VERSION << endl;
        exit(0);

    case ':':
        fprintf(stderr, "missing option arguments\n");
        wantsHelp = true;
        break;

    case '?':
        if (optopt == '?') {
        wantsHelp = true;
        } else {
        std::cerr << "Try --help for a summary of options.\n";
        exit(2);
        }
        break;

    default:
        die("getopt returned character code " << c << endl);

    }
    }

    if (wantsHelp || gotCommand==false) {
    help();
    exit(2);
    }

    XSBAgent agent;
    int exitStatus = 0;

    if (command == "conjoin") {
    InMemoryPool pool;

    for (std::vector<TripleSource*>::iterator i=sources.begin(); i!=sources.end(); ++i) {
        pool.mUnion(**i);
    }
    pool.printNTriples(std::cout);
    } else if (command == "common") {
    if (sources.size() != 2) {
        std::cerr << "the 'common' command uses two datasets\n";
        exit(2);
    }
    TripleSource* p = compare(agent, sources[0], sources[1], true, max);
    p->printNTriples(std::cout);
    delete p;
    } else if (command == "posdiff") {
    if (sources.size() != 2) {
        std::cerr << "the 'posdiff' command uses two datasets\n";
        exit(2);
    }
    TripleSource* p = compare(agent, sources[0], sources[1], false, max);
    TRACE "Diff results: " << *p;
    p->printNTriples(std::cout);
    if (p->count() > 0) exitStatus=1;
    delete p;
     } else if (command == "negdiff") {
    if (sources.size() != 2) {
        std::cerr << "the 'negdiff' command uses two datasets\n";
        exit(2);
    }
    TripleSource* p = compare(agent, sources[1], sources[0], false, max);
    p->printNTriples(std::cout);
    if (p->count() > 0) exitStatus=1;
    delete p;
     } else if (command == "diff") {
    if (sources.size() != 2) {
        std::cerr << "the 'diff' command uses two datasets\n";
        exit(2);
    }
    Pool* diff = compare(agent, sources[0], sources[1], false, max);
    size_t diffCount = diff->count();

    Pool* rdiff = compare(agent, sources[1], sources[0], false, max);
    size_t rdiffCount = rdiff->count();

    if (diffCount + rdiffCount > 0) exitStatus = 1;
    rdiff->printNTriples(std::cout, "< ");
    diff->printNTriples(std::cout, "> ");

    delete diff;
    delete rdiff;
     } else if (command == "report") {
    if (sources.size() != 2) {
        std::cerr << "the 'report' command uses two datasets\n";
        exit(2);
    }
    bool different = false;

    std::cout << sources[0]->count() << " triples in dataset A" << endl;
    std::cout << sources[1]->count() << " triples in dataset B" << endl;

    InMemoryPool u(*sources[0]);
    u.mUnion(*sources[1]);

    std::cout << u.count() << " triples in conjoin A B" << endl;

    TripleSource* inter = compare(agent, sources[0], sources[1], true, max);
    size_t interCount = inter->count();
    std::cout << interCount << " triples in common A B" << endl;

    Pool* diff = compare(agent, sources[0], sources[1], false, max);
    size_t diffCount = diff->count();
    std::cout << diffCount << " triples in posdiff A B  (A-common(A,B))" << endl;

    Pool* rdiff = compare(agent, sources[1], sources[0], false, max);
    size_t rdiffCount = rdiff->count();
    std::cout << rdiffCount << " triples in negdiff A B  (B-common(A,B))" << endl;

    if (diffCount + rdiffCount > 0) exitStatus = 1;
    } else {
    std::cout << "Unknown command \"" << command << "\"\n.";
    exit(2);
    }
    agent.shutdown();
    exit(exitStatus);
}

#undef TRACE_NAME

---

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