pred.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    pred.h
// Purpose:     Predicate Data for Loading Data Files (only EDB predicates)
// Last Change: 04.08.2017
// Language:    C++
// EMail:       brass@informatik.uni-halle.de
// WWW:         http://www.informatik.uni-halle.de/~brass/
// Address:     Feldschloesschen 15, D-06120 Halle (Saale), GERMANY
// Copyright:   (c) 2015-2017 by Stefan Brass
// License:     See file "LICENSE" for copying conditions.
// Note:        There is no warranty at all - this code may contain bugs.
// ============================================================================


//=============================================================================
// Include File Frame:
//=============================================================================

#ifndef PRED_INCLUDED
#define PRED_INCLUDED

//=============================================================================
// Used Types and Macros:
//=============================================================================

#ifndef VER_INCLUDED
#include "../base/ver.h"
#endif

#ifndef STR_INCLUDED
#include "../base/str.h"
#endif

#ifndef CHECK_INCLUDED
#include "../base/check.h"
#endif

#ifndef STRTAB_INCLUDED
#include "../dom/strtab.h"
#endif

#ifndef BIND_INCLUDED
#include "../rel/bind.h"
#endif

#ifndef REL_INCLUDED
#include "../rel/rel.h"
#endif

#ifndef LIST_1_INCLUDED
#include "../rel/list_1.h"
#endif

#ifndef LIST_2_INCLUDED
#include "../rel/list_2.h"
#endif

#ifndef SET_1_INCLUDED
#include "../rel/set_1.h"
#endif

#ifndef SET_2_INCLUDED
#include "../rel/set_2.h"
#endif

#ifndef REL_N_N_INCLUDED
#include "../rel/rel_n_n.h"
#endif

#ifndef ARGTYPE_INCLUDED
#include "argtype.h"
#endif


//=============================================================================
// Private Constants:
//=============================================================================

//-----------------------------------------------------------------------------
// PRED_MAX_RELS: Maximal number of of data structures to store facts.
//-----------------------------------------------------------------------------

static const int PRED_MAX_RELS = 5;

//-----------------------------------------------------------------------------
// PRED_MAGIC: Magic number (identifies objects of this class).
//-----------------------------------------------------------------------------

static const long PRED_MAGIC = 0x5052440AL;     // 'PRD\n'


//=============================================================================
// Class for EDB Predicates (Predicate Data for Loading Data Files):
//=============================================================================

class pred_c {
        public:


//-----------------------------------------------------------------------------
// Constructor, Destructor:
//-----------------------------------------------------------------------------

        // Constructor:
        pred_c(str_t pred_name, int pred_arity);

        // Constructor, Special Case for Predicates with one atom/string arg:
        pred_c(str_t pred_name, strtab_t dom_1);

        // Constructor, Special Case for Predicates with two atom/string args:
        pred_c(str_t pred_name, strtab_t dom_1, strtab_t dom_2);

        // Constructor, Special Case for Predicates with one numeric arg:
        pred_c(str_t pred_name, argtype_t argtype_1);

        // Constructor, Special Case for Predicates with two numeric args:
        pred_c(str_t pred_name, argtype_t argtype_1, argtype_t argtype_2);

        // Destructor:
        ~pred_c();


//-----------------------------------------------------------------------------
// (Object) Methods:
//-----------------------------------------------------------------------------

        // name: Return name of predicate.
        str_t name() {
                CHECK_VALID("pred_c::name");
                return Name;
        }

        // arity: Return arity of predicate.
        int arity() {
                CHECK_VALID("pred_c::arity");
                return Arity;
        }

        // set_argtype: Set argument type.
        void set_argtype(int arg_no, argtype_t arg_type) {
                CHECK_VALID("pred_c::set_argtype");
                CHECK(arg_no >= 0, "pred_c::set_argtype: arg_no is negative");
                CHECK(arg_no < Arity, "pred_c::set_argtype: arg_no too large");
                CHECK(ArgType[arg_no] == ARGTYPE_NULL,
                                "pred_c::set_argtype: argtype already set");
                CHECK(argtype_valid(arg_type),
                                "pred_c::set_argtype: arg_type is invalid");
                if(arg_no < VER_MAX_PRED_ARGS)
                        ArgType[arg_no] = arg_type;
        }

        // argtype: Get type of argument.
        argtype_t argtype(int arg_no) {
                CHECK_VALID("pred_c::argtype");
                CHECK(arg_no >= 0, "pred_c::argtype: arg_no is negative");
                CHECK(arg_no < Arity, "pred_c::argtype: arg_no too large");
                if(arg_no < VER_MAX_PRED_ARGS)
                        return ArgType[arg_no];
                else
                        return ARGTYPE_NULL;
        }

        // set_dom: Set domain for argument to string table.
        void set_dom(int arg_no, strtab_t dom) {
                CHECK_VALID("pred_c::set_dom");
                CHECK(arg_no >= 0, "pred_c::set_dom: arg_no is negative");
                CHECK(arg_no < Arity, "pred_c::set_dom: arg_no too large");
                CHECK_PAR(dom, "pred_c::set_dom");
                CHECK(Dom[arg_no] == STRTAB_NULL,
                                "pred_c::set_dom: arg_no is already set");
                if(arg_no < VER_MAX_PRED_ARGS)
                        Dom[arg_no] = dom;
        }

        // arg_dom: Get domain for argument to string table.
        strtab_t arg_dom(int arg_no) {
                CHECK_VALID("pred_c::arg_dom");
                CHECK(arg_no >= 0, "pred_c::arg_dom: arg_no is negative");
                CHECK(arg_no < Arity, "pred_c::arg_dom: arg_no too large");
                if(arg_no < VER_MAX_PRED_ARGS)
                        return Dom[arg_no];
                else
                        return STRTAB_NULL;
        }

        // add_rel: Add relation to store facts of this predicate.
        bool add_rel(rel_t rel, bind_t bind);

        // Special cases of add_rel:
        bool add_rel(list_1_t rel) {
                return add_rel(rel, BIND_F);
        }

        bool add_rel(list_2_t rel) {
                return add_rel(rel, BIND_FF);
        }

        bool add_rel(set_1_t rel) {
                return add_rel(rel, BIND_B);
        }

        bool add_rel(set_2_t rel) {
                return add_rel(rel, BIND_BB);
        }

        bool add_rel(rel_n_n_t rel) {
                return add_rel(rel, BIND_BF);
        }

        // store_fact: Store fact in all relations attached to this predicate:
        bool store_fact(int args[]);

        // hash_next: Return next predicate in hash chain.
        pred_c* hash_next() {
                CHECK_VALID("pred_c::hash_next");
                return HashNext;
        }

        // set_next: Set next predicate in hash chain.
        void set_next(pred_c *next_pred) {
                CHECK_VALID("pred_c::set_next");
                HashNext = next_pred;
        }


//-----------------------------------------------------------------------------
// Debugging Support:
//-----------------------------------------------------------------------------

#if     VER_DEBUG
        // Integrity check:
        public:
        str_t   check() const;

        // Magic number (identifies objects of this class for debugging).
        private:
        long    Magic;          // Must be "PRED_MAGIC".
#endif


#if     VER_DUMP
        public:
        // Display data structure:
        void dump(str_t headline = STR_NULL) const;
#endif

//-----------------------------------------------------------------------------
// Copy-constructor and assignment operator are not supported for this class:
//-----------------------------------------------------------------------------

        private:

        pred_c(const pred_c& atom);             // Not implemented
        pred_c& operator=(const pred_c& atom);  // Not implemented


//-----------------------------------------------------------------------------
// Private Object Members:
//-----------------------------------------------------------------------------

        private:

        // Name of the predicate:
        str_t Name;

        // Arity (number of arguments) of the predicate:
        int Arity;

        // Argument types:
        argtype_t ArgType[VER_MAX_PRED_ARGS];

        // Domains for storing the arguments:
        strtab_t Dom[VER_MAX_PRED_ARGS];

        // Number of relation data structures to recieve facts of this pred:
        int NumRels;

        // Data structures for storing the extension of this predicate:
        rel_t Rel[PRED_MAX_RELS];

        // Binding patterns for these relations:
        bind_t Bind[PRED_MAX_RELS];

        // Link to next predicate in hash chain (see class load_c).
        pred_c *HashNext;


//=============================================================================
// End of Class:
//=============================================================================

};

//-----------------------------------------------------------------------------
// Define pointer type:
//-----------------------------------------------------------------------------

typedef pred_c *pred_t;

//-----------------------------------------------------------------------------
// Define null pointer:
//-----------------------------------------------------------------------------

#define PRED_NULL (static_cast<pred_t>(0))

//=============================================================================
// End of Include File:
//=============================================================================

#endif