relation_join_fn * interval_relation_plugin::mk_join_fn(const relation_base & r1, const relation_base & r2,
unsigned col_cnt, const unsigned * cols1, const unsigned * cols2) {
if (!check_kind(r1) || !check_kind(r2)) {
return nullptr;
}
return alloc(join_fn, r1.get_signature(), r2.get_signature(), col_cnt, cols1, cols2);
}
relation_union_fn * external_relation_plugin::mk_widen_fn(const relation_base & tgt, const relation_base & src,
const relation_base * delta) {
if (!check_kind(tgt) || !check_kind(src) || (delta && !check_kind(*delta))) {
return 0;
}
return alloc(union_fn, *this, OP_RA_WIDEN, get(src).get_sort());
}
relation_intersection_filter_fn * external_relation_plugin::mk_filter_by_negation_fn(const relation_base & t,
const relation_base & negated_obj, unsigned joined_col_cnt,
const unsigned * t_cols, const unsigned * negated_cols) {
if (!check_kind(t) || !check_kind(negated_obj)) {
return 0;
}
return alloc(negation_filter_fn, *this, t, negated_obj, joined_col_cnt, t_cols, negated_cols);
}
table_union_fn* lazy_table_plugin::mk_union_fn(
const table_base & tgt, const table_base & src,
const table_base * delta) {
if (check_kind(tgt) && check_kind(src) && (!delta || check_kind(*delta))) {
return alloc(union_fn);
}
else {
return 0;
}
}
table_join_fn * lazy_table_plugin::mk_join_fn(
const table_base & t1, const table_base & t2,
unsigned col_cnt, const unsigned * cols1, const unsigned * cols2) {
if (check_kind(t1) && check_kind(t2)) {
return alloc(join_fn, t1.get_signature(), t2.get_signature(), col_cnt, cols1, cols2);
}
else {
return 0;
}
}
table_intersection_filter_fn * lazy_table_plugin::mk_filter_by_negation_fn(
const table_base & t,
const table_base & negated_obj, unsigned joined_col_cnt,
const unsigned * t_cols, const unsigned * negated_cols) {
if (check_kind(t) && check_kind(negated_obj)) {
return alloc(filter_by_negation_fn, joined_col_cnt, t_cols, negated_cols);
}
else {
return 0;
}
}
relation_transformer_fn * interval_relation_plugin::mk_rename_fn(const relation_base & r,
unsigned cycle_len, const unsigned * permutation_cycle) {
if(!check_kind(r)) {
return nullptr;
}
return alloc(rename_fn, r.get_signature(), cycle_len, permutation_cycle);
}
relation_mutator_fn * external_relation_plugin::mk_filter_identical_fn(const relation_base & r,
unsigned col_cnt, const unsigned * identical_cols) {
if (!check_kind(r)) {
return 0;
}
return alloc(filter_identical_fn, *this, get(r).get_sort(), col_cnt, identical_cols);
}
relation_transformer_fn * external_relation_plugin::mk_rename_fn(const relation_base & r,
unsigned cycle_len, const unsigned * permutation_cycle) {
if(!check_kind(r)) {
return 0;
}
return alloc(rename_fn, *this, get(r).get_sort(), r.get_signature(), cycle_len, permutation_cycle);
}
table_mutator_fn * lazy_table_plugin::mk_filter_equal_fn(
const table_base & t, const table_element & value, unsigned col) {
if (check_kind(t)) {
return alloc(filter_equal_fn, value, col);
}
else {
return 0;
}
}
table_mutator_fn * lazy_table_plugin::mk_filter_identical_fn(
const table_base & t, unsigned col_cnt, const unsigned * identical_cols) {
if (check_kind(t)) {
return alloc(filter_identical_fn, col_cnt, identical_cols);
}
else {
return 0;
}
}
table_mutator_fn * lazy_table_plugin::mk_filter_interpreted_fn(
const table_base & t, app* condition) {
if (check_kind(t)) {
app_ref cond(condition, get_ast_manager());
return alloc(filter_interpreted_fn, cond);
}
else {
return 0;
}
}
table_transformer_fn * lazy_table_plugin::mk_rename_fn(
const table_base & t, unsigned col_cnt,
const unsigned * removed_cols) {
if (check_kind(t)) {
return alloc(rename_fn, t.get_signature(), col_cnt, removed_cols);
}
else {
return 0;
}
}
relation_mutator_fn * external_relation_plugin::mk_filter_equal_fn(const relation_base & r,
const relation_element & value, unsigned col) {
if(!check_kind(r)) {
return 0;
}
ast_manager& m = get_ast_manager();
app_ref condition(m);
expr_ref var(m);
sort* relation_sort = get(r).get_sort();
sort* column_sort = get_column_sort(col, relation_sort);
var = m.mk_var(col, column_sort);
condition = m.mk_eq(var, value);
return mk_filter_interpreted_fn(r, condition);
}
relation_mutator_fn * external_relation_plugin::mk_filter_interpreted_fn(const relation_base & r, app * condition) {
if(!check_kind(r)) {
return 0;
}
return alloc(filter_interpreted_fn, *this, get(r).get_sort(), condition);
}
static PyObject*
automaton_new(PyTypeObject* self, PyObject* args, PyObject* kwargs) {
Automaton* automaton = NULL;
int store;
automaton = (Automaton*)PyObject_New(Automaton, &automaton_type);
if (UNLIKELY(automaton == NULL))
return NULL;
// commons settings
automaton->version = 0;
automaton->stats.version = -1;
automaton->count = 0;
automaton->longest_word = 0;
automaton->kind = EMPTY;
automaton->root = NULL;
if (UNLIKELY(PyTuple_Size(args) == 7)) {
// unpickle: count, data, kind, store, version, values
size_t count;
void* data;
size_t size;
int version;
int longest_word;
AutomatonKind kind;
KeysStore store;
PyObject* values = NULL;
if (not PyArg_ParseTuple(args, "iy#iiiiO", &count, &data, &size, &kind, &store, &version, &longest_word, &values)) {
PyErr_SetString(PyExc_ValueError, "invalid data to restore");
goto error;
}
if (not check_store(store) or not check_kind(kind))
goto error;
if (kind != EMPTY) {
if (automaton_unpickle(automaton, count, data, size, values)) {
automaton->kind = kind;
automaton->store = store;
automaton->version = version;
automaton->longest_word = longest_word;
}
else
goto error;
}
Py_DECREF(values);
}
else {
// construct new object
if (PyArg_ParseTuple(args, "i", &store)) {
if (not check_store(store))
goto error;
}
else {
PyErr_Clear();
store = STORE_ANY;
}
automaton->store = store;
}
//ok:
return (PyObject*)automaton;
error:
Py_XDECREF(automaton);
return NULL;
}
