base.h

#ifndef CLINGO_BASE_H
#define CLINGO_BASE_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <clingo/core.h>
#include <clingo/symbol.h>
 
typedef struct clingo_control clingo_control_t;
 
 
 
 
typedef struct clingo_signature {
    char const *name; 
    size_t size;      
    size_t arity;     
    bool is_positive; 
} clingo_signature_t;
 
typedef struct clingo_base clingo_base_t;
 
typedef struct clingo_atom_base clingo_atom_base_t;
 
typedef struct clingo_term_base clingo_term_base_t;
 
enum clingo_theory_term_type_e {
    clingo_theory_term_type_tuple = 0,    
    clingo_theory_term_type_list = 1,     
    clingo_theory_term_type_set = 2,      
    clingo_theory_term_type_function = 3, 
    clingo_theory_term_type_number = 4,   
    clingo_theory_term_type_symbol = 5    
};
typedef int clingo_theory_term_type_t;
 
typedef struct clingo_theory_base clingo_theory_base_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_base_is_fact(clingo_base_t const *atoms, clingo_literal_t literal, bool *is_fact);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_base_is_external(clingo_base_t const *atoms, clingo_literal_t literal,
                                                       bool *is_external);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_base_is_shown(clingo_base_t const *atoms, clingo_literal_t literal,
                                                    bool *is_shown);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_base_is_projected(clingo_base_t const *atoms, clingo_literal_t literal,
                                                        bool *is_projected);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_base_is_current(clingo_base_t const *atoms, clingo_literal_t literal,
                                                      bool *is_current);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_base_atoms_size(clingo_base_t const *base, size_t *size);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_base_atoms_at(clingo_base_t const *base, size_t index,
                                                    clingo_signature_t *signature, clingo_atom_base_t const **atoms);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_base_atoms_find(clingo_base_t const *base, clingo_signature_t const *signature,
                                                      clingo_atom_base_t const **atoms, bool *found);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_atom_base_size(clingo_atom_base_t const *atoms, size_t *size);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_atom_base_find(clingo_atom_base_t const *atoms, clingo_symbol_t symbol,
                                                     size_t *index);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_atom_base_symbol(clingo_atom_base_t const *atoms, size_t index,
                                                       clingo_symbol_t *symbol);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_atom_base_literal(clingo_atom_base_t const *atoms, size_t index,
                                                        clingo_literal_t *literal);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_base_terms(clingo_base_t const *base, clingo_term_base_t const **terms);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_base_theory(clingo_base_t const *base, clingo_theory_base_t const **theory);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_term_base_size(clingo_term_base_t const *terms, size_t *size);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_term_base_symbol(clingo_term_base_t const *terms, size_t index,
                                                       clingo_symbol_t *term);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_term_base_condition(clingo_term_base_t const *terms, size_t index,
                                                          size_t const **sizes,
                                                          clingo_literal_t const *const **literals, size_t *size);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_term_base_find(clingo_term_base_t const *terms, clingo_symbol_t symbol,
                                                     size_t *index);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_term_type(clingo_theory_base_t const *theory, clingo_id_t term,
                                                            clingo_theory_term_type_t *type);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_term_number(clingo_theory_base_t const *theory, clingo_id_t term,
                                                              int *number);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_term_name(clingo_theory_base_t const *theory, clingo_id_t term,
                                                            clingo_string_t *name);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_term_arguments(clingo_theory_base_t const *theory, clingo_id_t term,
                                                                 clingo_id_t const **arguments, size_t *size);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_term_to_string(clingo_theory_base_t const *theory, clingo_id_t term,
                                                                 clingo_string_builder_t *builder);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_element_tuple(clingo_theory_base_t const *theory, clingo_id_t element,
                                                                clingo_id_t const **tuple, size_t *size);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_element_condition(clingo_theory_base_t const *theory,
                                                                    clingo_id_t element,
                                                                    clingo_literal_t const **condition, size_t *size);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_element_condition_id(clingo_theory_base_t const *theory,
                                                                       clingo_id_t element,
                                                                       clingo_literal_t *condition);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_element_to_string(clingo_theory_base_t const *theory,
                                                                    clingo_id_t element,
                                                                    clingo_string_builder_t *builder);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_size(clingo_theory_base_t const *theory, size_t *size);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_atom_term(clingo_theory_base_t const *theory, clingo_id_t atom,
                                                            clingo_id_t *term);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_atom_elements(clingo_theory_base_t const *theory, clingo_id_t atom,
                                                                clingo_id_t const **elements, size_t *size);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_atom_has_guard(clingo_theory_base_t const *theory, clingo_id_t atom,
                                                                 bool *has_guard);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_atom_guard(clingo_theory_base_t const *theory, clingo_id_t atom,
                                                             clingo_string_t *connective, clingo_id_t *term);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_atom_literal(clingo_theory_base_t const *theory, clingo_id_t atom,
                                                               clingo_literal_t *literal);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_base_atom_to_string(clingo_theory_base_t const *theory, clingo_id_t atom,
                                                                 clingo_string_builder_t *builder);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_base(clingo_control_t const *control, clingo_base_t const **base);
 
 
#ifdef __cplusplus
}
#endif
 
#endif