std::shared_ptr<person_proxy> rebind( const std::shared_ptr<person>& p ) {
show( std::cout << "before rebind: " << this << " => " ); // test
if( is_cyclic(p) ) throw std::logic_error( "cyclic; can't be proxy for itself" ) ;
actual = p;
show( std::cout << "after rebind: " << this << " => " ) ; // test
return std::dynamic_pointer_cast<person_proxy>( shared_from_this() ) ;
}
std::vector<int> topological_sort(const std::set<int>& nodes,
const std::map<int,std::set<int>>& edges) {
// Check that graph is valid
if (!is_closure(nodes, edges)) {
std::stringstream err;
err << __FILE__ << " " << __LINE__ << " :: " << "graph is not a closure";
throw lbann_exception(err.str());
}
if (is_cyclic(nodes, edges)) {
std::stringstream err;
err << __FILE__ << " " << __LINE__ << " :: " << "graph is cyclic";
throw lbann_exception(err.str());
}
// Return original order if already sorted
if (is_topologically_sorted(nodes, edges)) {
return std::vector<int>(nodes.begin(), nodes.end());
}
// Perform depth-first searches on nodes
std::stack<int> sorted_stack;
std::unordered_map<int,bool> is_sorted;
for (const auto& root : nodes) {
if (!is_sorted[root]) {
const auto& dfs = depth_first_search(root, edges);
for (const auto& node : dfs) {
if (!is_sorted[node]) {
is_sorted[node] = true;
sorted_stack.push(node);
}
}
}
}
// Reverse DFS post-order is topologically sorted
std::vector<int> sorted_nodes;
while (!sorted_stack.empty()) {
sorted_nodes.push_back(sorted_stack.top());
sorted_stack.pop();
}
return sorted_nodes;
}
/* caller must ensure enough heap space (term_size(term)*sizeof(Cell)) */
prolog_term intern_term(CTXTdeclc prolog_term term) {
Integer ti = 0;
Cell arg, newterm, interned_term, orig_term;
unsigned int subterm_index;
XSB_Deref(term);
if (!(islist(term) || isconstr(term))) {return term;}
if (isinternstr(term)) {return term;}
if (is_cyclic(CTXTc term)) {xsb_abort("Cannot intern a cyclic term\n");}
// if (!ground(term)) {return term;}
orig_term = term;
// printf("iti: ");printterm(stdout,orig_term,100);printf("\n");
if (!ts_array) {
ts_array = mem_alloc(init_ts_array_len*sizeof(*ts_array),OTHER_SPACE);
if (!ts_array) xsb_abort("No space for interning term\n");
ts_array_len = init_ts_array_len;
}
ts_array[0].term = term;
if (islist(term)) {
ts_array[0].subterm_index = 0;
ts_array[0].newterm = makelist(hreg);
hreg += 2;
}
else {
// if (isboxedinteger(term)) printf("interning boxed int\n");
// else if (isboxedfloat(term)) printf("interning boxed float %f\n",boxedfloat_val(term));
ts_array[0].subterm_index = 1;
ts_array[0].newterm = makecs(hreg);
new_heap_functor(hreg, get_str_psc(term));
hreg += get_arity(get_str_psc(term));
}
ts_array[ti].ground = 1;
while (ti >= 0) {
term = ts_array[ti].term;
newterm = ts_array[ti].newterm;
subterm_index = ts_array[ti].subterm_index;
if ((islist(term) && subterm_index >= 2) ||
(isconstr(term) && subterm_index > get_arity(get_str_psc(term)))) {
if (ts_array[ti].ground) {
interned_term = intern_rec(CTXTc newterm);
if (!interned_term) xsb_abort("error term should have been interned\n");
hreg = clref_val(newterm); // reclaim used stack space
if (!ti) {
if (compare(CTXTc (void*)orig_term,(void*)interned_term) != 0) printf("NOT SAME\n");
//printf("itg: ");printterm(stdout,interned_term,100);printf("\n");
return interned_term;
}
ti--;
get_str_arg(ts_array[ti].newterm,ts_array[ti].subterm_index-1) = interned_term;
} else {
//printf("hreg = %p, ti=%d\n",hreg,ti);
if (!ti) {
if (compare(CTXTc (void*)orig_term,(void*)newterm) != 0) printf("NOT SAME\n");
//printf("ito: ");printterm(stdout,newterm,100);printf("\n");
return newterm;
}
ti--;
get_str_arg(ts_array[ti].newterm,ts_array[ti].subterm_index-1) = newterm;
ts_array[ti].ground = 0;
}
} else {
arg = get_str_arg(term, (ts_array[ti].subterm_index)++);
XSB_Deref(arg);
switch (cell_tag(arg)) {
case XSB_FREE:
case XSB_REF1:
case XSB_ATTV:
ts_array[ti].ground = 0;
get_str_arg(newterm,subterm_index) = arg;
break;
case XSB_STRING:
if (string_find_safe(string_val(arg)) != string_val(arg)) printf("uninterned string?\n");
case XSB_INT:
case XSB_FLOAT:
get_str_arg(newterm,subterm_index) = arg;
break;
case XSB_LIST:
if (isinternstr(arg)) get_str_arg(newterm,subterm_index) = arg;
else {
ti++;
check_ts_array_overflow;
ts_array[ti].term = arg;
ts_array[ti].subterm_index = 0;
ts_array[ti].ground = 1;
ts_array[ti].newterm = makelist(hreg);
hreg += 2;
}
break;
case XSB_STRUCT:
if (isinternstr(arg)) get_str_arg(newterm,subterm_index) = arg;
else {
// if (isboxedinteger(arg)) printf("interning boxed int\n");
// else if (isboxedfloat(arg)) printf("interning boxed float %f\n",boxedfloat_val(arg));
ti++;
check_ts_array_overflow;
ts_array[ti].term = arg;
ts_array[ti].subterm_index = 1;
ts_array[ti].ground = 1;
ts_array[ti].newterm = makecs(hreg);
new_heap_functor(hreg,get_str_psc(arg));
hreg += get_arity(get_str_psc(arg));
}
}
}
}
printf("intern_term: shouldn't happen\n");
return 0;
}
bool is_cyclic( const std::shared_ptr<person>& p ) const {
auto pp = std::dynamic_pointer_cast<person_proxy>(p) ;
if( pp && ( pp.get() == this ) ) return true ;
else return pp ? is_cyclic( pp->actual ) : false ;
}
