gen_cur1.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    gen_cur1.h
// Purpose:     Cursor over generated one-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_CUR1_INCLUDED
#define GEN_CUR1_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_CUR1_MAGIC: Magic number (identifies objects of this class).
//-----------------------------------------------------------------------------

static const long GEN_CUR1_MAGIC = 0x4743310AL; // 'GC1\n'

//=============================================================================
// Class for Cursor to Generated Relation with One Integer Column (for Tests):
//=============================================================================

class gen_cur1_c {
        public:

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

        // Constructor 1 with full parameter selection:
        gen_cur1_c(int type, int size, int max_value);

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

        // Destructor:
        ~gen_cur1_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_cur1_c::fetch");

                // Check state:
                CHECK(TupleNo != -1,
                        "gen_cur1_c::fetch: cursor not open");
                CHECK(TupleNo <= Size,
                        "gen_cur1_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;

                // Simple linear sequence:
                if(Type == 1) {
                        if(TupleNo == 1) {
                                // First fetch:
                                C1 = 0;
                        }
                        else {
                                C1++;
                        }
                        return true;
                }

                // Mixed sequences:
                if(Type == 2) {
                        int state = TupleNo % 6;
                        // Note that TupleNo is 1 for the first tuple.
                        switch(state) {
                                case 1:
                                case 4:
                                        if(BottomUp <= MaxValue) {
                                                C1 = BottomUp;
                                                BottomUp += 3;
                                                return true;
                                        }
                                        break;
                                case 0:
                                case 3:
                                        if(TopDown > 0) {
                                                C1 = TopDown;
                                                TopDown -= 3;
                                                return true;
                                        }
                                        break;
                                case 2:
                                        if(MiddleUp <= MaxValue) {
                                                C1 = MiddleUp;
                                                MiddleUp += 3;
                                                return true;
                                        }
                                        break;
                                case 5:
                                        if(MiddleDown > 0) {
                                                C1 = MiddleDown;
                                                MiddleDown -= 3;
                                                return true;
                                        }
                                        break;
                        }

                        // A limit has been reached. Take whatever possible:
                        if(BottomUp <= MaxValue) {
                                C1 = BottomUp;
                                BottomUp += 3;
                                return true;
                        }
                        if(TopDown > 0) {
                                C1 = TopDown;
                                TopDown -= 3;
                                return true;
                        }
                        if(MiddleUp <= MaxValue) {
                                C1 = MiddleUp;
                                MiddleUp += 3;
                                return true;
                        }
                        if(MiddleDown > 0) {
                                C1 = MiddleDown;
                                MiddleDown -= 3;
                                return true;
                        }
                        CHECK_IMPOSSIBLE("gen_cur1_c::fetch: No more values");
                }

                // We should never arrive here:
                return false;
        }

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

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

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

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

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

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

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

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

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

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

                // Save changeable attributes:
                if(!stack->push(TupleNo))
                        return false;
                if(!stack->push(C1))
                        return false;
                if(!stack->push(BottomUp))
                        return false;
                if(!stack->push(TopDown))
                        return false;
                if(!stack->push(MiddleUp))
                        return false;
                if(!stack->push(MiddleDown))
                        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_cur1_c::pop");

                // Restore changeable attributes (in opposite order):
                MiddleDown = stack->pop();
                MiddleUp   = stack->pop();
                TopDown    = stack->pop();
                BottomUp   = 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_CUR1_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_cur1_c(const gen_cur1_c& obj);              // Not implemented
        gen_cur1_c& operator=(const gen_cur1_c& obj);   // Not implemented

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

        private:

        // Type of this sequence
        // (1: simple sequential, 2: mixed sequences):
        int Type;

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

        // Maximal Value that can be used (domain size):
        int MaxValue;

        // Current tuple number:
        int TupleNo;

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

        // Current value of number generator starting at 0,
        // stepping +3 (this is always == 0 modulo 3):
        int BottomUp;

        // Current value of number generator starting at largest value
        // (that is == 1 mod 3) stepping -3 (this is always == 1 modulo 3):
        int TopDown;

        // Current value of number generator starting in the middle,
        // stepping +3 (this is always == 2 modulo 3):
        int MiddleUp;

        // Current value of number generator starting in the middle,
        // stepping -3 (this is always == 2 modulo 3):
        int MiddleDown;


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

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

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

};

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

typedef gen_cur1_c *gen_cur1_t;

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

#define GEN_CUR1_NULL (static_cast<gen_cur1_t>(0))

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

#endif