How to use

Evaluator

in

fr.inria.corese.kgram.api.query

/**
 * ********************************************************
 *
 * @param el
 */
public void addResultListener(ResultListener el) {
  listener = el;
  hasListener = listener != null;
  if (hasListener) {
    evaluator.addResultListener(el);
  }
}

/**
 * We just counted number of results: nbResult Just build a Mapping
 */
void countProfile() {
  Node n = evaluator.cast(nbResult, memory, producer);
  Mapping m = Mapping.create(query.getSelectFun().get(0).getNode(), n);
  results.add(m);
}

int compare(Node n1, Node n2) {
  return evaluator.compare(memory, producer, n1, n2);
}

 /**
 * use case: exists {} in aggregate select (count(if (exists { BGP }, ?x,
 * ?y)) as ?c) Env is a Mapping Copy Mapping into fresh Memory in order to
 * evaluate exists {} in Memory TODO: optimize by storing mem
 *
 *
 */
public Memory getMemory(Mapping map, Exp exp) {
  Memory mem = new Memory(match, evaluator);
  getEvaluator().init(mem);
  mem.init(query);
  mem.copy(map, exp);
  return mem;
}

public Object eval(Expr exp, Object[] param){
  return evaluator.eval(exp, memory, producer, param);
}

void initMemory(Query q) {
  if (memory == null) {
    // when subquery, memory is already assigned
    // assign stack index to EDGE and NODE
    q.complete(producer);//service while1 / Query
    memory = new Memory(match, evaluator); 
    memory.setEval(this);
    getEvaluator().init(memory);
    // create memory bind stack
    memory.init(q);
    if (hasEvent) {
      memory.setEventManager(manager);
    }
    producer.init(q);
    evaluator.start(memory);
    debug = q.isDebug();
    if (q.isAlgebra()){
      complete(q);
    }
    if (debug){
      System.out.println(q);
    }
  }
}

@Override
public boolean filter() {      
  Expr exp = eval.getEvaluator().getDefineMetadata(getEnvironment(), FILTER, 3);
  return (exp != null);
} 

Eval ev = memory.getEval();
if (n == HAVING) {
  res = eval.test(exp.getFilter(), memory);            
  if (ev != null) {
    ev.getVisitor().having(ev, exp.getFilter().getExp(), res);
    node = eval.eval(exp.getFilter(), memory, p);
    if (ev != null) {
      ev.getVisitor()

IDatatype funcall(String name, IDatatype[] param, Evaluator eval, Environment env, Producer p) {
  Function fun = (Function) eval.getDefine(env, name, param.length);
  if (fun != null) {
    return call(fun, param, eval, env, p);
  }
  return null;
}

public IDatatype methodBasic(Eval ev, String name, IDatatype type, IDatatype[] param) {       
  Function exp = (Function) eval.getEvaluator().getDefineMethod(getEnvironment(), name, type, param);
  if (exp != null) {
    IDatatype dt = call(exp, param, ev.getEvaluator(), ev.getEnvironment(), ev.getProducer());
    return dt;
  }
  return null;
}

  /**
   * Edge as Function use case: ?x xpath('/book/title') ?y
   */
  private int eval(Node gNode, Exp exp, Stack stack, int n) {
    int backtrack = n - 1;
    Edge qEdge = exp.getEdge();
    Node qNode = qEdge.getNode(1);
    Memory env = memory;
    Evaluator ev = evaluator;
    Matcher mm = match;

    for (Node node : ev.evalList(exp.getFilter(), env)) {

      if (mm.match(qNode, node, env) && env.push(qNode, node)) {

        backtrack = eval(gNode, stack, n + 1);
        env.pop(qNode);
        if (backtrack < n) {
//                    if (hasEvent){
//                        send(Event.FINISH, exp, gNode, stack);
//                    }
          return backtrack;
        }
      }
    }
    return backtrack;
  }

  debug();
evaluator.finish(memory);
return results;

/**
 * copy memory for sub query 
 * copy sub query select variables that are
 * already bound in current memory
 * Use case: subquery and exists
 */
private Memory copyMemory(Memory memory, Query query, Query sub, Exp exp) {
  Memory mem = new Memory(match, evaluator);
  getEvaluator().init(mem);
  if (sub == null) {
    mem.init(query);
  } else {
    mem.init(sub);
  }
  memory.copyInto(sub, mem, exp);
  if (hasEvent) {
    memory.setEventManager(manager);
  }
  return mem;
}

/**
 * Generate a unique Blank Node wrt query that represents the path Use a
 * predefined filter pathNode()
 */
Node getPathNode(Path p) {
  Filter f = query.getGlobalFilter(Query.PATHNODE);
  Node node = evaluator.eval(f, memory, producer);
  node.setObject(p);
  return node;
}

@Override
public boolean filter() {      
  Expr exp = eval.getEvaluator().getDefineMetadata(getEnvironment(), FILTER, 3);
  return (exp != null);
} 

IDatatype funcall(String name, IDatatype[] param, Evaluator eval, Environment env, Producer p) {
  Function fun = (Function) eval.getDefine(env, name, param.length);
  if (fun != null) {
    return call(fun, param, eval, env, p);
  }
  return null;
}

public IDatatype methodBasic(Eval ev, String name, IDatatype type, IDatatype[] param) {       
  Function exp = (Function) eval.getEvaluator().getDefineMethod(getEnvironment(), name, type, param);
  if (exp != null) {
    IDatatype dt = call(exp, param, ev.getEvaluator(), ev.getEnvironment(), ev.getProducer());
    return dt;
  }
  return null;
}

void init(Memory env) {
  mem = new Memory(matcher, evaluator);
  mem.init(env.getQuery());
  mem.init(env);
  mem.setFake(true);
  evaluator.init(mem);
  mem.share(mem.getBind(), env.getBind());
  mem.setEval(kgram);
}

/**
 * Mapping as Environment may compute aggregates see same function in Memory
 */
@Override
public void aggregate(Evaluator eval, Producer p, Filter f) {
  if (!getMappings().isFake()) {
    for (Mapping map : getMappings()) {
      // in case there is a nested aggregate
      eval.eval(f, map, p);
    }
  }
}

boolean define(String name, int arity) {
  Expr exp = eval.getEvaluator().getDefineMetadata(getEnvironment(), name, arity);
  return (exp != null);
}