gen_cur2.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    gen_cur2.h
// Purpose:     Cursor over generated two-column relations (for tests).
// 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) 2016-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 GEN_CUR2_INCLUDED
#define GEN_CUR2_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 STACK_INCLUDED
#include "../bds/stack.h"
#endif

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

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

static const long GEN_CUR2_MAGIC = 0x4743320AL; // 'GC2\n'

//=============================================================================
// Class for Cursor to Generated Relation with Two Integer Columns (for Tests):
//=============================================================================

class gen_cur2_c {
        public:

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

        // Constructor 1 with full parameter selection:
        gen_cur2_c(int size, int c1_start, int c1_step, int c1_max,
                        int c2_start, int c2_step, int c2_max);

        // Constructor 2 with simplified relation ID:
        gen_cur2_c(int rel_id);

        // Destructor:
        ~gen_cur2_c();

//-----------------------------------------------------------------------------
// Methods:
//-----------------------------------------------------------------------------

        // open: Open the cursor.
        void open();

        // fetch: Get next tuple, returns false if there is no further tuple.
        bool fetch() {

                // Check this object:
                CHECK_VALID("gen_cur2_c::fetch");

                // Check state:
                CHECK(TupleNo != -1,
                        "gen_cur2_c::fetch: cursor not open");
                CHECK(TupleNo <= Size,
                        "gen_cur2_c::fetch: fetch beyond end");

                // Increase tuple number (counts number of fetches):
                TupleNo++;

                // Check whether we are at the end of the relation:
                if(TupleNo > Size)
                        return false;

                // Initialization (first fetch):
                if(TupleNo == 1) {
                        C1 = Start1;
                        C2 = Start2;
                }

                // Compute next tuple:
                else {
                        // Compute next value of column 1:
                        if(C1 <= Max1 - Step1)
                                C1 += Step1;
                        else if(Iter1 < Step1) {
                                C1 = Start1 + Iter1;
                                Iter1++;
                        }
                        else {
                                CHECK_IMPOSSIBLE(
                                        "gen_cur2_c::fetch: No more values 1");
                                C1 = -1;
                                C2 = -1;
                                return false;
                        }

                        // Compute next value of column 2:
                        if(C2 <= Max2 - Step2)
                                C2 += Step2;
                        else if(Iter2 < Step2) {
                                C2 = Start2 + Iter2;
                                Iter2++;
                        }
                        else {
                                CHECK_IMPOSSIBLE(
                                        "gen_cur2_c::fetch: No more values 2");
                                C1 = -1;
                                C2 = -1;
                                return false;
                        }
                }

                // Done:
                return true;
        }

        // c1: Return value of column 1 to which the cursor points.
        int c1() {

                // Check this object:
                CHECK_VALID("gen_cur2_c::c1");

                // Check state:
                CHECK(TupleNo != -1,
                        "gen_cur2_c::c1: cursor not open");
                CHECK(TupleNo > 0,
                        "gen_cur2_c::c1: fetch must be called first");
                CHECK(TupleNo <= Size,
                        "gen_cur2_c::c1: fetch beyond end");

                // Return current value for column 1:
                return C1;
        }

        // c2: Return value of column 2 to which the cursor points.
        int c2() {

                // Check this object:
                CHECK_VALID("gen_cur2_c::c2");

                // Check state:
                CHECK(TupleNo != -1,
                        "gen_cur2_c::c2: cursor not open");
                CHECK(TupleNo > 0,
                        "gen_cur2_c::c2: fetch must be called first");
                CHECK(TupleNo <= Size,
                        "gen_cur2_c::c2: fetch beyond end");

                // Return current value for column 2:
                return C2;
        }

        // close: Close cursor.
        void close() {

                // Check this object:
                CHECK_VALID("gen_cur2_c::close");

                // Check state:
                CHECK(TupleNo >= 0,
                        "gen_cur2_c::close: cursor not open");

                // Close cursor:
                TupleNo = -1;
                C1 = -1;
                C2 = -1;
        }

        // push: Save the cursor state on a stack.
        bool push(stack_c<int> *stack) {

                // Check this object:
                CHECK_VALID("gen_cur2_c::push");

                // Save changeable attributes:
                if(!stack->push(TupleNo))
                        return false;
                if(!stack->push(C1))
                        return false;
                if(!stack->push(C2))
                        return false;
                if(!stack->push(Iter1))
                        return false;
                if(!stack->push(Iter2))
                        return false;

                // Ok:
                return true;
        }

        // pop: Restore the cursor state from a stack.
        void pop(stack_c<int> *stack) {

                // Check this object:
                CHECK_VALID("gen_cur2_c::pop");

                // Restore changeable attributes (in opposite order):
                Iter2 = stack->pop();
                Iter1 = stack->pop();
                C2    = stack->pop();
                C1    = stack->pop();
                TupleNo = stack->pop();
        }

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

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

        private:
        // Magic number (identifies objects of this class for debugging).
        long    Magic;          // Must be "GEN_CUR2_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:

        gen_cur2_c(const gen_cur2_c& obj);              // Not implemented
        gen_cur2_c& operator=(const gen_cur2_c& obj);   // Not implemented

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

        private:

        // Relation size (number of tuples to be generated):
        int Size;

        // Start value of column 1:
        int Start1;

        // Step distance for column 1:
        int Step1;

        // Maximal Value that can be used for column 1:
        int Max1;

        // Start value of column 2:
        int Start2;

        // Step distance for column 2:
        int Step2;

        // Maximal Value that can be used for column 2:
        int Max2;

        // Current tuple number:
        int TupleNo;

        // Current value for column 1 in the tuple sequence:
        int C1;

        // Current value for column 2 in the tuple sequence:
        int C2;

        // Current iteration counter for column 1 (number of restarts - 1):
        // The restart is at Start1 + Iter1 (to generate distinct values).
        // If Iter1 >= Step1, no further restart is possible.
        int Iter1;

        // Current iteration counter for column 2 (number of restarts - 1):
        int Iter2;


//-----------------------------------------------------------------------------
// Auxiliary Methods:
//-----------------------------------------------------------------------------

        // Initialize sequence generator attributes:
        void init();

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

};

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

typedef gen_cur2_c *gen_cur2_t;

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

#define GEN_CUR2_NULL (static_cast<gen_cur2_t>(0))

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

#endif